From 0b7dc9740ee1a7f67d3fd27db447331db7d25ae3 Mon Sep 17 00:00:00 2001 From: Wim Haeck Date: Thu, 8 Aug 2024 14:33:45 -0600 Subject: [PATCH] Adding python bindings and tests --- CMakeLists.txt | 2 + cmake/unit_testing_python.cmake | 2 + python/src/TabulatedFormFactor.python.cpp | 100 ++ .../TabulatedScatteringFunction.python.cpp | 100 ++ python/src/dryad.python.cpp | 4 + python/test/Test_dryad_TabulatedFormFactor.py | 1571 +++++++++++++++++ .../Test_dryad_TabulatedScatteringFunction.py | 1571 +++++++++++++++++ 7 files changed, 3350 insertions(+) create mode 100644 python/src/TabulatedFormFactor.python.cpp create mode 100644 python/src/TabulatedScatteringFunction.python.cpp create mode 100644 python/test/Test_dryad_TabulatedFormFactor.py create mode 100644 python/test/Test_dryad_TabulatedScatteringFunction.py diff --git a/CMakeLists.txt b/CMakeLists.txt index 6a50559..3df63a6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -110,6 +110,8 @@ if( dryad.python ) python/src/TabulatedAngularDistributions.python.cpp python/src/TabulatedEnergyDistribution.python.cpp python/src/TabulatedEnergyDistributions.python.cpp + python/src/TabulatedFormFactor.python.cpp + python/src/TabulatedScatteringFunction.python.cpp python/src/TwoBodyDistributionData.python.cpp python/src/UncorrelatedDistributionData.python.cpp python/src/ReactionProduct.python.cpp diff --git a/cmake/unit_testing_python.cmake b/cmake/unit_testing_python.cmake index 8488649..fc6cd33 100644 --- a/cmake/unit_testing_python.cmake +++ b/cmake/unit_testing_python.cmake @@ -32,6 +32,8 @@ add_python_test( TabulatedAngularDistribution Test_dryad_TabulatedAngularDistri add_python_test( TabulatedAngularDistributions Test_dryad_TabulatedAngularDistributions.py ) add_python_test( TabulatedEnergyDistribution Test_dryad_TabulatedEnergyDistribution.py ) add_python_test( TabulatedEnergyDistributions Test_dryad_TabulatedEnergyDistributions.py ) +add_python_test( TabulatedFormFactor Test_dryad_TabulatedFormFactor.py ) +add_python_test( TabulatedScatteringFunction Test_dryad_TabulatedScatteringFunction.py ) add_python_test( TwoBodyDistributionData Test_dryad_TwoBodyDistributionData.py ) add_python_test( UncorrelatedDistributionData Test_dryad_UncorrelatedDistributionData.py ) add_python_test( ReactionProduct Test_dryad_ReactionProduct.py ) diff --git a/python/src/TabulatedFormFactor.python.cpp b/python/src/TabulatedFormFactor.python.cpp new file mode 100644 index 0000000..f2500cf --- /dev/null +++ b/python/src/TabulatedFormFactor.python.cpp @@ -0,0 +1,100 @@ +// system includes +#include +#include +#include + +// local includes +#include "definitions.hpp" +#include "dryad/TabulatedFormFactor.hpp" + +// namespace aliases +namespace python = pybind11; + +void wrapTabulatedFormFactor( python::module& module, python::module& ) { + + // type aliases + using Component = njoy::dryad::TabulatedFormFactor; + using InterpolationType = njoy::dryad::InterpolationType; + using ToleranceConvergence = njoy::dryad::ToleranceConvergence; + + // wrap views created by this component + + // create the component + python::class_< Component > component( + + module, + "TabulatedFormFactor", + "A form factor table" + ); + + // wrap the component + component + .def( + + python::init< std::vector< double >, std::vector< double >, + std::vector< std::size_t >, + std::vector< InterpolationType > >(), + python::arg( "energies" ), python::arg( "values" ), + python::arg( "boundaries" ), python::arg( "interpolants" ), + "Initialise the form factor table\n\n" + "Arguments:\n" + " self the form factor table\n" + " energies the energy values\n" + " values the form factor values\n" + " boundaries the boundaries of the interpolation regions\n" + " interpolants the interpolation types of the interpolation regions,\n" + " see InterpolationType for all interpolation types" + ) + .def( + + python::init< std::vector< double >, std::vector< double >, + InterpolationType >(), + python::arg( "energies" ), python::arg( "values" ), + python::arg( "interpolant" ) = InterpolationType::LinearLinear, + "Initialise the form factor table\n\n" + "Arguments:\n" + " self the form factor table\n" + " energies the energy values\n" + " values the form factor values\n" + " interpolant the interpolation type (default lin-lin),\n" + " see InterpolationType for all interpolation types" + ) + .def_property_readonly( + + "energies", + &Component::energies, + "The energy values" + ) + .def_property_readonly( + + "values", + &Component::values, + "The form factor values" + ) + .def_property_readonly( + + "lower_energy_limit", + &Component::lowerEnergyLimit, + "The lower energy limit" + ) + .def_property_readonly( + + "upper_energy_limit", + &Component::upperEnergyLimit, + "The upper energy limit" + ) + .def( + + "__call__", + [] ( const Component& self, double energy ) -> decltype(auto) + { return self( energy ); }, + python::arg( "energy" ), + "Evaluate the table for a given energy value\n\n" + "Arguments:\n" + " self the table\n" + " energy the energy value" + ); + + // add standard tabulated data definitions + addStandardTabulatedDefinitions< Component >( component ); +} diff --git a/python/src/TabulatedScatteringFunction.python.cpp b/python/src/TabulatedScatteringFunction.python.cpp new file mode 100644 index 0000000..f86bfaa --- /dev/null +++ b/python/src/TabulatedScatteringFunction.python.cpp @@ -0,0 +1,100 @@ +// system includes +#include +#include +#include + +// local includes +#include "definitions.hpp" +#include "dryad/TabulatedScatteringFunction.hpp" + +// namespace aliases +namespace python = pybind11; + +void wrapTabulatedScatteringFunction( python::module& module, python::module& ) { + + // type aliases + using Component = njoy::dryad::TabulatedScatteringFunction; + using InterpolationType = njoy::dryad::InterpolationType; + using ToleranceConvergence = njoy::dryad::ToleranceConvergence; + + // wrap views created by this component + + // create the component + python::class_< Component > component( + + module, + "TabulatedScatteringFunction", + "A scattering function table" + ); + + // wrap the component + component + .def( + + python::init< std::vector< double >, std::vector< double >, + std::vector< std::size_t >, + std::vector< InterpolationType > >(), + python::arg( "inverse_lengths" ), python::arg( "values" ), + python::arg( "boundaries" ), python::arg( "interpolants" ), + "Initialise the scattering function table\n\n" + "Arguments:\n" + " self the scattering function table\n" + " inverse_lengths the inverse length values\n" + " values the scattering function values\n" + " boundaries the boundaries of the interpolation regions\n" + " interpolants the interpolation types of the interpolation regions,\n" + " see InterpolationType for all interpolation types" + ) + .def( + + python::init< std::vector< double >, std::vector< double >, + InterpolationType >(), + python::arg( "inverse_lengths" ), python::arg( "values" ), + python::arg( "interpolant" ) = InterpolationType::LinearLinear, + "Initialise the scattering function table\n\n" + "Arguments:\n" + " self the scattering function table\n" + " inverse_lengths the inverse length values\n" + " values the scattering function values\n" + " interpolant the interpolation type (default lin-lin),\n" + " see InterpolationType for all interpolation types" + ) + .def_property_readonly( + + "inverse_lengths", + &Component::inverseLengths, + "The inverse length values" + ) + .def_property_readonly( + + "values", + &Component::values, + "The scattering function values" + ) + .def_property_readonly( + + "lower_inverse_length_limit", + &Component::lowerInverseLengthLimit, + "The lower inverse length limit" + ) + .def_property_readonly( + + "upper_inverse_length_limit", + &Component::upperInverseLengthLimit, + "The upper inverse length limit" + ) + .def( + + "__call__", + [] ( const Component& self, double inverse_length ) -> decltype(auto) + { return self( inverse_length ); }, + python::arg( "inverse_length" ), + "Evaluate the table for a given energy value\n\n" + "Arguments:\n" + " self the table\n" + " inverse_length the inverse length value" + ); + + // add standard tabulated data definitions + addStandardTabulatedDefinitions< Component >( component ); +} diff --git a/python/src/dryad.python.cpp b/python/src/dryad.python.cpp index 358aaf5..1c285db 100644 --- a/python/src/dryad.python.cpp +++ b/python/src/dryad.python.cpp @@ -27,6 +27,8 @@ void wrapTabulatedEnergyDistributions( python::module&, python::module& ); void wrapTabulatedCrossSection( python::module&, python::module& ); void wrapTabulatedMultiplicity( python::module&, python::module& ); void wrapTabulatedAverageEnergy( python::module&, python::module& ); +void wrapTabulatedFormFactor( python::module&, python::module& ); +void wrapTabulatedScatteringFunction( python::module&, python::module& ); void wrapTwoBodyDistributionData( python::module&, python::module& ); void wrapUncorrelatedDistributionData( python::module&, python::module& ); void wrapReactionProduct( python::module&, python::module& ); @@ -73,6 +75,8 @@ PYBIND11_MODULE( dryad, module ) { wrapTabulatedAngularDistributions( module, viewmodule ); wrapTabulatedEnergyDistribution( module, viewmodule ); wrapTabulatedEnergyDistributions( module, viewmodule ); + wrapTabulatedFormFactor( module, viewmodule ); + wrapTabulatedScatteringFunction( module, viewmodule ); wrapTwoBodyDistributionData( module, viewmodule ); wrapUncorrelatedDistributionData( module, viewmodule ); wrapReactionProduct( module, viewmodule ); diff --git a/python/test/Test_dryad_TabulatedFormFactor.py b/python/test/Test_dryad_TabulatedFormFactor.py new file mode 100644 index 0000000..3005770 --- /dev/null +++ b/python/test/Test_dryad_TabulatedFormFactor.py @@ -0,0 +1,1571 @@ +# standard imports +import unittest +import sys + +# third party imports + +# local imports +from dryad import TabulatedFormFactor +from dryad import InterpolationType + +class Test_dryad_TabulatedFormFactor( unittest.TestCase ) : + """Unit test for the TabulatedFormFactor class.""" + + def test_component( self ) : + + def verify_chunk1( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_energy_limit ) + self.assertAlmostEqual( 4., chunk.upper_energy_limit ) + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 3., chunk.energies[2] ) + self.assertAlmostEqual( 4., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( True, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( energy = 1. ) ) + self.assertAlmostEqual( 3., chunk( energy = 2. ) ) + self.assertAlmostEqual( 2., chunk( energy = 3. ) ) + self.assertAlmostEqual( 1., chunk( energy = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( energy = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( energy = 5. ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.5, chunk( energy = 1.5 ) ) + self.assertAlmostEqual( 2.5, chunk( energy = 2.5 ) ) + self.assertAlmostEqual( 1.5, chunk( energy = 3.5 ) ) + + # verify arithmetic operators + same = TabulatedFormFactor( [ 1., 4. ], [ 0., 3. ] ) + threshold = TabulatedFormFactor( [ 2., 4. ], [ 0., 2. ] ) + nonzerothreshold = TabulatedFormFactor( [ 2., 4. ], [ 1., 3. ] ) + small = TabulatedFormFactor( [ 1., 3. ], [ 0., 2. ] ) + + result = -chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 3., result.energies[2] ) + self.assertAlmostEqual( 4., result.energies[3] ) + self.assertAlmostEqual( -4., result.values[0] ) + self.assertAlmostEqual( -3., result.values[1] ) + self.assertAlmostEqual( -2., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 3., chunk.energies[2] ) + self.assertAlmostEqual( 4., chunk.energies[3] ) + self.assertAlmostEqual( 6., chunk.values[0] ) + self.assertAlmostEqual( 5., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk -= 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 3., chunk.energies[2] ) + self.assertAlmostEqual( 4., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk *= 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 3., chunk.energies[2] ) + self.assertAlmostEqual( 4., chunk.energies[3] ) + self.assertAlmostEqual( 8., chunk.values[0] ) + self.assertAlmostEqual( 6., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 2., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk /= 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 3., chunk.energies[2] ) + self.assertAlmostEqual( 4., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 3., result.energies[2] ) + self.assertAlmostEqual( 4., result.energies[3] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = 2. + chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 3., result.energies[2] ) + self.assertAlmostEqual( 4., result.energies[3] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk - 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 3., result.energies[2] ) + self.assertAlmostEqual( 4., result.energies[3] ) + self.assertAlmostEqual( 2., result.values[0] ) + self.assertAlmostEqual( 1., result.values[1] ) + self.assertAlmostEqual( 0., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = 2. - chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 3., result.energies[2] ) + self.assertAlmostEqual( 4., result.energies[3] ) + self.assertAlmostEqual( -2., result.values[0] ) + self.assertAlmostEqual( -1., result.values[1] ) + self.assertAlmostEqual( 0., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk * 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 3., result.energies[2] ) + self.assertAlmostEqual( 4., result.energies[3] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 2., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = 2. * chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 3., result.energies[2] ) + self.assertAlmostEqual( 4., result.energies[3] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 2., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk / 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 3. , result.energies[2] ) + self.assertAlmostEqual( 4. , result.energies[3] ) + self.assertAlmostEqual( 2. , result.values[0] ) + self.assertAlmostEqual( 1.5, result.values[1] ) + self.assertAlmostEqual( 1. , result.values[2] ) + self.assertAlmostEqual( 0.5, result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += same + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.energies[0] ) + self.assertAlmostEqual( 2. , chunk.energies[1] ) + self.assertAlmostEqual( 3. , chunk.energies[2] ) + self.assertAlmostEqual( 4. , chunk.energies[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 4.0, chunk.values[1] ) + self.assertAlmostEqual( 4.0, chunk.values[2] ) + self.assertAlmostEqual( 4.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk -= same + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.energies[0] ) + self.assertAlmostEqual( 2. , chunk.energies[1] ) + self.assertAlmostEqual( 3. , chunk.energies[2] ) + self.assertAlmostEqual( 4. , chunk.energies[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 2.0, chunk.values[2] ) + self.assertAlmostEqual( 1.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + same + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 3. , result.energies[2] ) + self.assertAlmostEqual( 4. , result.energies[3] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 4.0, result.values[1] ) + self.assertAlmostEqual( 4.0, result.values[2] ) + self.assertAlmostEqual( 4.0, result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk - same + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 3. , result.energies[2] ) + self.assertAlmostEqual( 4. , result.energies[3] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 2., result.values[1] ) + self.assertAlmostEqual( 0., result.values[2] ) + self.assertAlmostEqual( -2., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += threshold + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.energies[0] ) + self.assertAlmostEqual( 2. , chunk.energies[1] ) + self.assertAlmostEqual( 3. , chunk.energies[2] ) + self.assertAlmostEqual( 4. , chunk.energies[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 3.0, chunk.values[2] ) + self.assertAlmostEqual( 3.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk -= threshold + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.energies[0] ) + self.assertAlmostEqual( 2. , chunk.energies[1] ) + self.assertAlmostEqual( 3. , chunk.energies[2] ) + self.assertAlmostEqual( 4. , chunk.energies[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 2.0, chunk.values[2] ) + self.assertAlmostEqual( 1.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + threshold + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 3. , result.energies[2] ) + self.assertAlmostEqual( 4. , result.energies[3] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 3.0, result.values[1] ) + self.assertAlmostEqual( 3.0, result.values[2] ) + self.assertAlmostEqual( 3.0, result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk - threshold + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.energies ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 3. , result.energies[2] ) + self.assertAlmostEqual( 4. , result.energies[3] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 1., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += nonzerothreshold + self.assertEqual( 5, chunk.number_points ) + self.assertEqual( 2, chunk.number_regions ) + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.energies[0] ) + self.assertAlmostEqual( 2. , chunk.energies[1] ) + self.assertAlmostEqual( 2. , chunk.energies[2] ) + self.assertAlmostEqual( 3. , chunk.energies[3] ) + self.assertAlmostEqual( 4. , chunk.energies[4] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 4.0, chunk.values[2] ) + self.assertAlmostEqual( 4.0, chunk.values[3] ) + self.assertAlmostEqual( 4.0, chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= nonzerothreshold + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.energies[0] ) + self.assertAlmostEqual( 2. , chunk.energies[1] ) + self.assertAlmostEqual( 3. , chunk.energies[2] ) + self.assertAlmostEqual( 4. , chunk.energies[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 2.0, chunk.values[2] ) + self.assertAlmostEqual( 1.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + nonzerothreshold + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 2. , result.energies[2] ) + self.assertAlmostEqual( 3. , result.energies[3] ) + self.assertAlmostEqual( 4. , result.energies[4] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 3.0, result.values[1] ) + self.assertAlmostEqual( 4.0, result.values[2] ) + self.assertAlmostEqual( 4.0, result.values[3] ) + self.assertAlmostEqual( 4.0, result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - nonzerothreshold + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 2. , result.energies[2] ) + self.assertAlmostEqual( 3. , result.energies[3] ) + self.assertAlmostEqual( 4. , result.energies[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 2., result.values[2] ) + self.assertAlmostEqual( 0., result.values[3] ) + self.assertAlmostEqual( -2., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + # this will add a second point at the lower end point + result = chunk + small + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 3. , result.energies[2] ) + self.assertAlmostEqual( 3. , result.energies[3] ) + self.assertAlmostEqual( 4. , result.energies[4] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 4.0, result.values[1] ) + self.assertAlmostEqual( 4.0, result.values[2] ) + self.assertAlmostEqual( 2.0, result.values[3] ) + self.assertAlmostEqual( 1.0, result.values[4] ) + self.assertEqual( 2, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + # this will add a second point at the lower end point + result = chunk - small + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 3. , result.energies[2] ) + self.assertAlmostEqual( 3. , result.energies[3] ) + self.assertAlmostEqual( 4. , result.energies[4] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 2.0, result.values[1] ) + self.assertAlmostEqual( 0.0, result.values[2] ) + self.assertAlmostEqual( 2.0, result.values[3] ) + self.assertAlmostEqual( 1.0, result.values[4] ) + self.assertEqual( 2, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 4, linear.number_points ) + self.assertEqual( 1, linear.number_regions ) + + self.assertEqual( 4, len( linear.energies ) ) + self.assertEqual( 4, len( linear.values ) ) + self.assertEqual( 1, len( linear.boundaries ) ) + self.assertEqual( 1, len( linear.interpolants ) ) + + self.assertEqual( 3, linear.boundaries[0] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + + self.assertAlmostEqual( 1., linear.energies[0] ) + self.assertAlmostEqual( 2., linear.energies[1] ) + self.assertAlmostEqual( 3., linear.energies[2] ) + self.assertAlmostEqual( 4., linear.energies[3] ) + + self.assertAlmostEqual( 4., linear.values[0] ) + self.assertAlmostEqual( 3., linear.values[1] ) + self.assertAlmostEqual( 2., linear.values[2] ) + self.assertAlmostEqual( 1., linear.values[3] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk2( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_energy_limit ) + self.assertAlmostEqual( 4., chunk.upper_energy_limit ) + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + self.assertEqual( True, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( energy = 1. ) ) + self.assertAlmostEqual( 4., chunk( energy = 2. ) ) + self.assertAlmostEqual( 3., chunk( energy = 3. ) ) + self.assertAlmostEqual( 2., chunk( energy = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( energy = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( energy = 5. ) ) + + # verify evaluation - values of x inside the x grid + self.assertAlmostEqual( 3.5, chunk( energy = 1.5 ) ) + self.assertAlmostEqual( 3.5, chunk( energy = 2.5 ) ) + self.assertAlmostEqual( 2.5, chunk( energy = 3.5 ) ) + + # verify arithmetic operators + same = TabulatedFormFactor( [ 1., 4. ], [ 0., 3. ] ) + threshold = TabulatedFormFactor( [ 2., 4. ], [ 0., 2. ] ) + nonzerothreshold = TabulatedFormFactor( [ 3., 4. ], [ 1., 2. ] ) + small = TabulatedFormFactor( [ 1., 3. ], [ 0., 2. ] ) + + result = -chunk + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( -4., result.values[0] ) + self.assertAlmostEqual( -3., result.values[1] ) + self.assertAlmostEqual( -4., result.values[2] ) + self.assertAlmostEqual( -3., result.values[3] ) + self.assertAlmostEqual( -2., result.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk += 2. + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 6., chunk.values[0] ) + self.assertAlmostEqual( 5., chunk.values[1] ) + self.assertAlmostEqual( 6., chunk.values[2] ) + self.assertAlmostEqual( 5., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= 2. + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk *= 2. + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 8., chunk.values[0] ) + self.assertAlmostEqual( 6., chunk.values[1] ) + self.assertAlmostEqual( 8., chunk.values[2] ) + self.assertAlmostEqual( 6., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk /= 2. + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + 2. + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 6., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = 2. + chunk + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 6., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - 2. + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 2., result.values[0] ) + self.assertAlmostEqual( 1., result.values[1] ) + self.assertAlmostEqual( 2., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertAlmostEqual( 0., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = 2. - chunk + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( -2., result.values[0] ) + self.assertAlmostEqual( -1., result.values[1] ) + self.assertAlmostEqual( -2., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertAlmostEqual( 0., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk * 2. + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 8., result.values[2] ) + self.assertAlmostEqual( 6., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = 2. * chunk + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 8., result.values[2] ) + self.assertAlmostEqual( 6., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk / 2. + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.energies[0] ) + self.assertAlmostEqual( 2. , result.energies[1] ) + self.assertAlmostEqual( 2. , result.energies[2] ) + self.assertAlmostEqual( 3. , result.energies[3] ) + self.assertAlmostEqual( 4. , result.energies[4] ) + self.assertAlmostEqual( 2. , result.values[0] ) + self.assertAlmostEqual( 1.5, result.values[1] ) + self.assertAlmostEqual( 2. , result.values[2] ) + self.assertAlmostEqual( 1.5, result.values[3] ) + self.assertAlmostEqual( 1. , result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + chunk += same + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 4., chunk.values[1] ) + self.assertAlmostEqual( 5., chunk.values[2] ) + self.assertAlmostEqual( 5., chunk.values[3] ) + self.assertAlmostEqual( 5., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= same + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + same + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 4., result.values[1] ) + self.assertAlmostEqual( 5., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 5., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - same + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 2., result.values[1] ) + self.assertAlmostEqual( 3., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertAlmostEqual( -1., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + chunk += threshold + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 4., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= threshold + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + threshold + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 4., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - threshold + self.assertEqual( 5, len( result.energies ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 4., result.energies[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 2., result.values[3] ) + self.assertAlmostEqual( 0., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + chunk += nonzerothreshold + self.assertEqual( 6, len( chunk.energies ) ) + self.assertEqual( 6, len( chunk.values ) ) + self.assertEqual( 3, len( chunk.boundaries ) ) + self.assertEqual( 3, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 3., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.energies[5] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertAlmostEqual( 4., chunk.values[5] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 3, chunk.boundaries[1] ) + self.assertEqual( 5, chunk.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[2] ) + + chunk -= nonzerothreshold + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + nonzerothreshold + self.assertEqual( 6, len( result.energies ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 3., result.energies[4] ) + self.assertAlmostEqual( 4., result.energies[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertAlmostEqual( 4., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + result = chunk - nonzerothreshold + self.assertEqual( 6, len( result.energies ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 3., result.energies[4] ) + self.assertAlmostEqual( 4., result.energies[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertAlmostEqual( 2., result.values[4] ) + self.assertAlmostEqual( 0., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + # this will add a second point at the lower end point + result = chunk + small + self.assertEqual( 6, len( result.energies ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 3., result.energies[4] ) + self.assertAlmostEqual( 4., result.energies[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 4., result.values[1] ) + self.assertAlmostEqual( 5., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 3., result.values[4] ) + self.assertAlmostEqual( 2., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + # this will add a second point at the lower end point + result = chunk - small + self.assertEqual( 6, len( result.energies ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.energies[0] ) + self.assertAlmostEqual( 2., result.energies[1] ) + self.assertAlmostEqual( 2., result.energies[2] ) + self.assertAlmostEqual( 3., result.energies[3] ) + self.assertAlmostEqual( 3., result.energies[4] ) + self.assertAlmostEqual( 4., result.energies[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 2., result.values[1] ) + self.assertAlmostEqual( 3., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertAlmostEqual( 3., result.values[4] ) + self.assertAlmostEqual( 2., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 5, linear.number_points ) + self.assertEqual( 2, linear.number_regions ) + + self.assertEqual( 5, len( linear.energies ) ) + self.assertEqual( 5, len( linear.values ) ) + self.assertEqual( 2, len( linear.boundaries ) ) + self.assertEqual( 2, len( linear.interpolants ) ) + + self.assertEqual( 1, linear.boundaries[0] ) + self.assertEqual( 4, linear.boundaries[1] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[1] ) + + self.assertAlmostEqual( 1., linear.energies[0] ) + self.assertAlmostEqual( 2., linear.energies[1] ) + self.assertAlmostEqual( 2., linear.energies[2] ) + self.assertAlmostEqual( 3., linear.energies[3] ) + self.assertAlmostEqual( 4., linear.energies[4] ) + + self.assertAlmostEqual( 4., linear.values[0] ) + self.assertAlmostEqual( 3., linear.values[1] ) + self.assertAlmostEqual( 4., linear.values[2] ) + self.assertAlmostEqual( 3., linear.values[3] ) + self.assertAlmostEqual( 2., linear.values[4] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk3( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_energy_limit ) + self.assertAlmostEqual( 4., chunk.upper_energy_limit ) + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 2, chunk.number_regions ) + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 3., chunk.energies[2] ) + self.assertAlmostEqual( 4., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 3, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( energy = 1. ) ) + self.assertAlmostEqual( 3., chunk( energy = 2. ) ) + self.assertAlmostEqual( 2., chunk( energy = 3. ) ) + self.assertAlmostEqual( 1., chunk( energy = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( energy = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( energy = 5. ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.5, chunk( energy = 1.5 ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 2.44966028678679, chunk( energy = 2.5 ) ) + self.assertAlmostEqual( 1.46416306545103, chunk( energy = 3.5 ) ) + + # verify arithmetic operators throw exceptions + temp = TabulatedFormFactor( [ 1., 4. ], [ 4., 1. ] ) + with self.assertRaises( Exception ) : result = -chunk + with self.assertRaises( Exception ) : result = chunk + 2. + with self.assertRaises( Exception ) : result = chunk - 2. + with self.assertRaises( Exception ) : result = chunk * 2. + with self.assertRaises( Exception ) : result = chunk / 2. + with self.assertRaises( Exception ) : result = chunk + temp + with self.assertRaises( Exception ) : result = chunk - temp + with self.assertRaises( Exception ) : chunk += 2. + with self.assertRaises( Exception ) : chunk -= 2. + with self.assertRaises( Exception ) : chunk *= 2. + with self.assertRaises( Exception ) : chunk /= 2. + with self.assertRaises( Exception ) : chunk += temp + with self.assertRaises( Exception ) : chunk -= temp + with self.assertRaises( Exception ) : result = 2. + chunk + with self.assertRaises( Exception ) : result = 2. - chunk + with self.assertRaises( Exception ) : result = 2. * chunk + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 18, linear.number_points ) + self.assertEqual( 1, linear.number_regions ) + + self.assertEqual( 18, len( linear.energies ) ) + self.assertEqual( 18, len( linear.values ) ) + self.assertEqual( 1, len( linear.boundaries ) ) + self.assertEqual( 1, len( linear.interpolants ) ) + + self.assertEqual( 17, linear.boundaries[0] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + + self.assertAlmostEqual( 1. , linear.energies[0] ) + self.assertAlmostEqual( 2. , linear.energies[1] ) + self.assertAlmostEqual( 2.125, linear.energies[2] ) + self.assertAlmostEqual( 2.25 , linear.energies[3] ) + self.assertAlmostEqual( 2.375, linear.energies[4] ) + self.assertAlmostEqual( 2.5 , linear.energies[5] ) + self.assertAlmostEqual( 2.625, linear.energies[6] ) + self.assertAlmostEqual( 2.75 , linear.energies[7] ) + self.assertAlmostEqual( 2.875, linear.energies[8] ) + self.assertAlmostEqual( 3. , linear.energies[9] ) + self.assertAlmostEqual( 3.125, linear.energies[10] ) + self.assertAlmostEqual( 3.25 , linear.energies[11] ) + self.assertAlmostEqual( 3.375, linear.energies[12] ) + self.assertAlmostEqual( 3.5 , linear.energies[13] ) + self.assertAlmostEqual( 3.625, linear.energies[14] ) + self.assertAlmostEqual( 3.75 , linear.energies[15] ) + self.assertAlmostEqual( 3.875, linear.energies[16] ) + self.assertAlmostEqual( 4. , linear.energies[17] ) + + self.assertAlmostEqual( 4. , linear.values[0] ) + self.assertAlmostEqual( 3. , linear.values[1] ) + self.assertAlmostEqual( 2.85048128530886, linear.values[2] ) + self.assertAlmostEqual( 2.70951129135145, linear.values[3] ) + self.assertAlmostEqual( 2.57616511633150, linear.values[4] ) + self.assertAlmostEqual( 2.44966028678679, linear.values[5] ) + self.assertAlmostEqual( 2.32932893596581, linear.values[6] ) + self.assertAlmostEqual( 2.21459646033567, linear.values[7] ) + self.assertAlmostEqual( 2.10496492439848, linear.values[8] ) + self.assertAlmostEqual( 2. , linear.values[9] ) + self.assertAlmostEqual( 1.85810031827028, linear.values[10] ) + self.assertAlmostEqual( 1.72176678584324, linear.values[11] ) + self.assertAlmostEqual( 1.59057916034679, linear.values[12] ) + self.assertAlmostEqual( 1.46416306545103, linear.values[13] ) + self.assertAlmostEqual( 1.34218354996644, linear.values[14] ) + self.assertAlmostEqual( 1.22433973930853, linear.values[15] ) + self.assertAlmostEqual( 1.11036036428687, linear.values[16] ) + self.assertAlmostEqual( 1. , linear.values[17] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk4( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_energy_limit ) + self.assertAlmostEqual( 4., chunk.upper_energy_limit ) + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( energy = 1. ) ) + self.assertAlmostEqual( 4., chunk( energy = 2. ) ) + self.assertAlmostEqual( 3., chunk( energy = 3. ) ) + self.assertAlmostEqual( 2., chunk( energy = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( energy = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( energy = 5. ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.5, chunk( energy = 1.5 ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.44966028678679, chunk( energy = 2.5 ) ) + self.assertAlmostEqual( 2.46416306545103, chunk( energy = 3.5 ) ) + + # verify arithmetic operators throw exceptions + temp = TabulatedFormFactor( [ 1., 4. ], [ 4., 1. ] ) + with self.assertRaises( Exception ) : result = -chunk + with self.assertRaises( Exception ) : result = chunk + 2. + with self.assertRaises( Exception ) : result = chunk - 2. + with self.assertRaises( Exception ) : result = chunk * 2. + with self.assertRaises( Exception ) : result = chunk / 2. + with self.assertRaises( Exception ) : result = chunk + temp + with self.assertRaises( Exception ) : result = chunk - temp + with self.assertRaises( Exception ) : chunk += 2. + with self.assertRaises( Exception ) : chunk -= 2. + with self.assertRaises( Exception ) : chunk *= 2. + with self.assertRaises( Exception ) : chunk /= 2. + with self.assertRaises( Exception ) : chunk += temp + with self.assertRaises( Exception ) : chunk -= temp + with self.assertRaises( Exception ) : result = 2. + chunk + with self.assertRaises( Exception ) : result = 2. - chunk + with self.assertRaises( Exception ) : result = 2. * chunk + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 12, linear.number_points ) + self.assertEqual( 2, linear.number_regions ) + + self.assertEqual( 12, len( linear.energies ) ) + self.assertEqual( 12, len( linear.values ) ) + self.assertEqual( 2, len( linear.boundaries ) ) + self.assertEqual( 2, len( linear.interpolants ) ) + + self.assertEqual( 1, linear.boundaries[0] ) + self.assertEqual( 11, linear.boundaries[1] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[1] ) + + self.assertAlmostEqual( 1. , linear.energies[0] ) + self.assertAlmostEqual( 2. , linear.energies[1] ) + self.assertAlmostEqual( 2. , linear.energies[2] ) + self.assertAlmostEqual( 2.125, linear.energies[3] ) + self.assertAlmostEqual( 2.25 , linear.energies[4] ) + self.assertAlmostEqual( 2.5 , linear.energies[5] ) + self.assertAlmostEqual( 2.75 , linear.energies[6] ) + self.assertAlmostEqual( 3. , linear.energies[7] ) + self.assertAlmostEqual( 3.25 , linear.energies[8] ) + self.assertAlmostEqual( 3.5 , linear.energies[9] ) + self.assertAlmostEqual( 3.75 , linear.energies[10] ) + self.assertAlmostEqual( 4. , linear.energies[11] ) + + self.assertAlmostEqual( 4. , linear.values[0] ) + self.assertAlmostEqual( 3. , linear.values[1] ) + self.assertAlmostEqual( 4. , linear.values[2] ) + self.assertAlmostEqual( 3.85048128530886, linear.values[3] ) + self.assertAlmostEqual( 3.70951129135145, linear.values[4] ) + self.assertAlmostEqual( 3.44966028678679, linear.values[5] ) + self.assertAlmostEqual( 3.21459646033567, linear.values[6] ) + self.assertAlmostEqual( 3. , linear.values[7] ) + self.assertAlmostEqual( 2.72176678584324, linear.values[8] ) + self.assertAlmostEqual( 2.46416306545103, linear.values[9] ) + self.assertAlmostEqual( 2.22433973930853, linear.values[10] ) + self.assertAlmostEqual( 2. , linear.values[11] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk5( self, chunk ) : + + # verify content + self.assertEqual( 5, len( chunk.energies ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 2., chunk.energies[2] ) + self.assertAlmostEqual( 3., chunk.energies[3] ) + self.assertAlmostEqual( 4., chunk.energies[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) # <-- this is changed from 2 to 1 + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + def verify_chunk6( self, chunk ) : + + # verify content + self.assertEqual( 4, len( chunk.energies ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.energies[0] ) + self.assertAlmostEqual( 2., chunk.energies[1] ) + self.assertAlmostEqual( 3., chunk.energies[2] ) + self.assertAlmostEqual( 4., chunk.energies[3] ) # <-- last point removed + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) # <-- last point removed + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 3, chunk.boundaries[1] ) # <-- boundary value reset + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + # the data is given explicitly for data without boundaries + chunk = TabulatedFormFactor( energies = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + interpolant = InterpolationType.LinearLinear ) + + verify_chunk1( self, chunk ) + + # the data is given explicitly for data without boundaries and a jump + chunk = TabulatedFormFactor( energies = [ 1., 2., 2., 3., 4. ], + values = [ 4., 3., 4., 3., 2. ], + interpolant = InterpolationType.LinearLinear ) + + verify_chunk2( self, chunk ) + + # the data is given explicitly for data without a jump + chunk = TabulatedFormFactor( energies = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + boundaries = [ 1, 3 ], + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk3( self, chunk ) + + # the data is given explicitly for data with a jump + chunk = TabulatedFormFactor( energies = [ 1., 2., 2., 3., 4. ], + values = [ 4., 3., 4., 3., 2. ], + boundaries = [ 1, 4 ], + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk4( self, chunk ) + + # the data is given explicitly with boundaries that point to the second x value in the jump + chunk = TabulatedFormFactor( energies = [ 1., 2., 2., 3., 4. ], + values = [ 4., 3., 4., 3., 2. ], + boundaries = [ 2, 4 ], # <-- pointing to end of the jump + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk5( self, chunk ) + + # the data is given explicitly with a jump at the end that goes to zero + chunk = TabulatedFormFactor( energies = [ 1., 2., 3., 4., 4. ], # <-- jump at end + values = [ 4., 3., 2., 1., 0. ], # <-- last value is zero + boundaries = [ 1, 4 ], # <-- pointing to end + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk6( self, chunk ) + + def test_failures( self ) : + + print( '\n' ) + + # there are not enough values in the x or y grid + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [], values = [] ) + + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1. ], values = [ 4. ] ) + + # the x and y grid do not have the same number of points + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2. ] ) + + # the boundaries and interpolants do not have the same size + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + boundaries = [ 3 ], + interpolants = [] ) + + # the x grid is not sorted + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1., 3., 2., 4. ], + values = [ 4., 3., 2., 1. ] ) + + # the x grid contains a triple x value + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1., 2., 2., 2., 3., 4. ], + values = [ 4., 3., 3., 3., 2., 1. ] ) + + # the x grid has a jump at the beginning + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1., 1., 3., 4. ], + values = [ 4., 3., 1., 4. ] ) + + # the x grid has a jump at the end + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1., 2., 4., 4. ], + values = [ 4., 3., 1., 4. ] ) + + # the last boundary does not point to the last point + with self.assertRaises( Exception ) : + + chunk = TabulatedFormFactor( energies = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + boundaries = [ 2 ], + interpolants = [ InterpolationType.LinearLinear ] ) + +if __name__ == '__main__' : + + unittest.main() diff --git a/python/test/Test_dryad_TabulatedScatteringFunction.py b/python/test/Test_dryad_TabulatedScatteringFunction.py new file mode 100644 index 0000000..ffc6945 --- /dev/null +++ b/python/test/Test_dryad_TabulatedScatteringFunction.py @@ -0,0 +1,1571 @@ +# standard imports +import unittest +import sys + +# third party imports + +# local imports +from dryad import TabulatedScatteringFunction +from dryad import InterpolationType + +class Test_dryad_TabulatedScatteringFunction( unittest.TestCase ) : + """Unit test for the TabulatedScatteringFunction class.""" + + def test_component( self ) : + + def verify_chunk1( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_inverse_length_limit ) + self.assertAlmostEqual( 4., chunk.upper_inverse_length_limit ) + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( True, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( inverse_length = 1. ) ) + self.assertAlmostEqual( 3., chunk( inverse_length = 2. ) ) + self.assertAlmostEqual( 2., chunk( inverse_length = 3. ) ) + self.assertAlmostEqual( 1., chunk( inverse_length = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( inverse_length = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( inverse_length = 5. ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.5, chunk( inverse_length = 1.5 ) ) + self.assertAlmostEqual( 2.5, chunk( inverse_length = 2.5 ) ) + self.assertAlmostEqual( 1.5, chunk( inverse_length = 3.5 ) ) + + # verify arithmetic operators + same = TabulatedScatteringFunction( [ 1., 4. ], [ 0., 3. ] ) + threshold = TabulatedScatteringFunction( [ 2., 4. ], [ 0., 2. ] ) + nonzerothreshold = TabulatedScatteringFunction( [ 2., 4. ], [ 1., 3. ] ) + small = TabulatedScatteringFunction( [ 1., 3. ], [ 0., 2. ] ) + + result = -chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 3., result.inverse_lengths[2] ) + self.assertAlmostEqual( 4., result.inverse_lengths[3] ) + self.assertAlmostEqual( -4., result.values[0] ) + self.assertAlmostEqual( -3., result.values[1] ) + self.assertAlmostEqual( -2., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 6., chunk.values[0] ) + self.assertAlmostEqual( 5., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk -= 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk *= 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 8., chunk.values[0] ) + self.assertAlmostEqual( 6., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 2., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk /= 2. + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 3., result.inverse_lengths[2] ) + self.assertAlmostEqual( 4., result.inverse_lengths[3] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = 2. + chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 3., result.inverse_lengths[2] ) + self.assertAlmostEqual( 4., result.inverse_lengths[3] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk - 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 3., result.inverse_lengths[2] ) + self.assertAlmostEqual( 4., result.inverse_lengths[3] ) + self.assertAlmostEqual( 2., result.values[0] ) + self.assertAlmostEqual( 1., result.values[1] ) + self.assertAlmostEqual( 0., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = 2. - chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 3., result.inverse_lengths[2] ) + self.assertAlmostEqual( 4., result.inverse_lengths[3] ) + self.assertAlmostEqual( -2., result.values[0] ) + self.assertAlmostEqual( -1., result.values[1] ) + self.assertAlmostEqual( 0., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk * 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 3., result.inverse_lengths[2] ) + self.assertAlmostEqual( 4., result.inverse_lengths[3] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 2., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = 2. * chunk + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 3., result.inverse_lengths[2] ) + self.assertAlmostEqual( 4., result.inverse_lengths[3] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 2., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk / 2. + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 2. , result.values[0] ) + self.assertAlmostEqual( 1.5, result.values[1] ) + self.assertAlmostEqual( 1. , result.values[2] ) + self.assertAlmostEqual( 0.5, result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += same + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 4.0, chunk.values[1] ) + self.assertAlmostEqual( 4.0, chunk.values[2] ) + self.assertAlmostEqual( 4.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk -= same + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 2.0, chunk.values[2] ) + self.assertAlmostEqual( 1.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + same + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 4.0, result.values[1] ) + self.assertAlmostEqual( 4.0, result.values[2] ) + self.assertAlmostEqual( 4.0, result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk - same + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 2., result.values[1] ) + self.assertAlmostEqual( 0., result.values[2] ) + self.assertAlmostEqual( -2., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += threshold + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 3.0, chunk.values[2] ) + self.assertAlmostEqual( 3.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + chunk -= threshold + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 2.0, chunk.values[2] ) + self.assertAlmostEqual( 1.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + threshold + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 3.0, result.values[1] ) + self.assertAlmostEqual( 3.0, result.values[2] ) + self.assertAlmostEqual( 3.0, result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + result = chunk - threshold + self.assertEqual( 4, result.number_points ) + self.assertEqual( 1, result.number_regions ) + self.assertEqual( 4, len( result.inverse_lengths ) ) + self.assertEqual( 4, len( result.values ) ) + self.assertEqual( 1, len( result.boundaries ) ) + self.assertEqual( 1, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 1., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertEqual( 3, result.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + chunk += nonzerothreshold + self.assertEqual( 5, chunk.number_points ) + self.assertEqual( 2, chunk.number_regions ) + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2. , chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3. , chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4. , chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 4.0, chunk.values[2] ) + self.assertAlmostEqual( 4.0, chunk.values[3] ) + self.assertAlmostEqual( 4.0, chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= nonzerothreshold + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 1, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 1, len( chunk.boundaries ) ) + self.assertEqual( 1, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1. , chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4. , chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4.0, chunk.values[0] ) + self.assertAlmostEqual( 3.0, chunk.values[1] ) + self.assertAlmostEqual( 2.0, chunk.values[2] ) + self.assertAlmostEqual( 1.0, chunk.values[3] ) + self.assertEqual( 3, chunk.boundaries[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + + result = chunk + nonzerothreshold + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[4] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 3.0, result.values[1] ) + self.assertAlmostEqual( 4.0, result.values[2] ) + self.assertAlmostEqual( 4.0, result.values[3] ) + self.assertAlmostEqual( 4.0, result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - nonzerothreshold + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 2., result.values[2] ) + self.assertAlmostEqual( 0., result.values[3] ) + self.assertAlmostEqual( -2., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + # this will add a second point at the lower end point + result = chunk + small + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[4] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 4.0, result.values[1] ) + self.assertAlmostEqual( 4.0, result.values[2] ) + self.assertAlmostEqual( 2.0, result.values[3] ) + self.assertAlmostEqual( 1.0, result.values[4] ) + self.assertEqual( 2, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + # this will add a second point at the lower end point + result = chunk - small + self.assertEqual( 5, result.number_points ) + self.assertEqual( 2, result.number_regions ) + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[4] ) + self.assertAlmostEqual( 4.0, result.values[0] ) + self.assertAlmostEqual( 2.0, result.values[1] ) + self.assertAlmostEqual( 0.0, result.values[2] ) + self.assertAlmostEqual( 2.0, result.values[3] ) + self.assertAlmostEqual( 1.0, result.values[4] ) + self.assertEqual( 2, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 4, linear.number_points ) + self.assertEqual( 1, linear.number_regions ) + + self.assertEqual( 4, len( linear.inverse_lengths ) ) + self.assertEqual( 4, len( linear.values ) ) + self.assertEqual( 1, len( linear.boundaries ) ) + self.assertEqual( 1, len( linear.interpolants ) ) + + self.assertEqual( 3, linear.boundaries[0] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + + self.assertAlmostEqual( 1., linear.inverse_lengths[0] ) + self.assertAlmostEqual( 2., linear.inverse_lengths[1] ) + self.assertAlmostEqual( 3., linear.inverse_lengths[2] ) + self.assertAlmostEqual( 4., linear.inverse_lengths[3] ) + + self.assertAlmostEqual( 4., linear.values[0] ) + self.assertAlmostEqual( 3., linear.values[1] ) + self.assertAlmostEqual( 2., linear.values[2] ) + self.assertAlmostEqual( 1., linear.values[3] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk2( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_inverse_length_limit ) + self.assertAlmostEqual( 4., chunk.upper_inverse_length_limit ) + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + self.assertEqual( True, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( inverse_length = 1. ) ) + self.assertAlmostEqual( 4., chunk( inverse_length = 2. ) ) + self.assertAlmostEqual( 3., chunk( inverse_length = 3. ) ) + self.assertAlmostEqual( 2., chunk( inverse_length = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( inverse_length = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( inverse_length = 5. ) ) + + # verify evaluation - values of x inside the x grid + self.assertAlmostEqual( 3.5, chunk( inverse_length = 1.5 ) ) + self.assertAlmostEqual( 3.5, chunk( inverse_length = 2.5 ) ) + self.assertAlmostEqual( 2.5, chunk( inverse_length = 3.5 ) ) + + # verify arithmetic operators + same = TabulatedScatteringFunction( [ 1., 4. ], [ 0., 3. ] ) + threshold = TabulatedScatteringFunction( [ 2., 4. ], [ 0., 2. ] ) + nonzerothreshold = TabulatedScatteringFunction( [ 3., 4. ], [ 1., 2. ] ) + small = TabulatedScatteringFunction( [ 1., 3. ], [ 0., 2. ] ) + + result = -chunk + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( -4., result.values[0] ) + self.assertAlmostEqual( -3., result.values[1] ) + self.assertAlmostEqual( -4., result.values[2] ) + self.assertAlmostEqual( -3., result.values[3] ) + self.assertAlmostEqual( -2., result.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk += 2. + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 6., chunk.values[0] ) + self.assertAlmostEqual( 5., chunk.values[1] ) + self.assertAlmostEqual( 6., chunk.values[2] ) + self.assertAlmostEqual( 5., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= 2. + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk *= 2. + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 8., chunk.values[0] ) + self.assertAlmostEqual( 6., chunk.values[1] ) + self.assertAlmostEqual( 8., chunk.values[2] ) + self.assertAlmostEqual( 6., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk /= 2. + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + 2. + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 6., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = 2. + chunk + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 6., result.values[0] ) + self.assertAlmostEqual( 5., result.values[1] ) + self.assertAlmostEqual( 6., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - 2. + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 2., result.values[0] ) + self.assertAlmostEqual( 1., result.values[1] ) + self.assertAlmostEqual( 2., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertAlmostEqual( 0., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = 2. - chunk + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( -2., result.values[0] ) + self.assertAlmostEqual( -1., result.values[1] ) + self.assertAlmostEqual( -2., result.values[2] ) + self.assertAlmostEqual( -1., result.values[3] ) + self.assertAlmostEqual( 0., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk * 2. + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 8., result.values[2] ) + self.assertAlmostEqual( 6., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = 2. * chunk + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 8., result.values[0] ) + self.assertAlmostEqual( 6., result.values[1] ) + self.assertAlmostEqual( 8., result.values[2] ) + self.assertAlmostEqual( 6., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk / 2. + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1. , result.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[1] ) + self.assertAlmostEqual( 2. , result.inverse_lengths[2] ) + self.assertAlmostEqual( 3. , result.inverse_lengths[3] ) + self.assertAlmostEqual( 4. , result.inverse_lengths[4] ) + self.assertAlmostEqual( 2. , result.values[0] ) + self.assertAlmostEqual( 1.5, result.values[1] ) + self.assertAlmostEqual( 2. , result.values[2] ) + self.assertAlmostEqual( 1.5, result.values[3] ) + self.assertAlmostEqual( 1. , result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + chunk += same + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 4., chunk.values[1] ) + self.assertAlmostEqual( 5., chunk.values[2] ) + self.assertAlmostEqual( 5., chunk.values[3] ) + self.assertAlmostEqual( 5., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= same + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + same + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 4., result.values[1] ) + self.assertAlmostEqual( 5., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 5., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - same + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 2., result.values[1] ) + self.assertAlmostEqual( 3., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertAlmostEqual( -1., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + chunk += threshold + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 4., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + chunk -= threshold + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + threshold + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 4., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + result = chunk - threshold + self.assertEqual( 5, len( result.inverse_lengths ) ) + self.assertEqual( 5, len( result.values ) ) + self.assertEqual( 2, len( result.boundaries ) ) + self.assertEqual( 2, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 4., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 2., result.values[3] ) + self.assertAlmostEqual( 0., result.values[4] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 4, result.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + + chunk += nonzerothreshold + self.assertEqual( 6, len( chunk.inverse_lengths ) ) + self.assertEqual( 6, len( chunk.values ) ) + self.assertEqual( 3, len( chunk.boundaries ) ) + self.assertEqual( 3, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[5] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 4., chunk.values[4] ) + self.assertAlmostEqual( 4., chunk.values[5] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 3, chunk.boundaries[1] ) + self.assertEqual( 5, chunk.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[2] ) + + chunk -= nonzerothreshold + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[1] ) + + result = chunk + nonzerothreshold + self.assertEqual( 6, len( result.inverse_lengths ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 3., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.inverse_lengths[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertAlmostEqual( 4., result.values[4] ) + self.assertAlmostEqual( 4., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + result = chunk - nonzerothreshold + self.assertEqual( 6, len( result.inverse_lengths ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 3., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.inverse_lengths[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 3., result.values[1] ) + self.assertAlmostEqual( 4., result.values[2] ) + self.assertAlmostEqual( 3., result.values[3] ) + self.assertAlmostEqual( 2., result.values[4] ) + self.assertAlmostEqual( 0., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + # this will add a second point at the lower end point + result = chunk + small + self.assertEqual( 6, len( result.inverse_lengths ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 3., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.inverse_lengths[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 4., result.values[1] ) + self.assertAlmostEqual( 5., result.values[2] ) + self.assertAlmostEqual( 5., result.values[3] ) + self.assertAlmostEqual( 3., result.values[4] ) + self.assertAlmostEqual( 2., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + # this will add a second point at the lower end point + result = chunk - small + self.assertEqual( 6, len( result.inverse_lengths ) ) + self.assertEqual( 6, len( result.values ) ) + self.assertEqual( 3, len( result.boundaries ) ) + self.assertEqual( 3, len( result.interpolants ) ) + self.assertAlmostEqual( 1., result.inverse_lengths[0] ) + self.assertAlmostEqual( 2., result.inverse_lengths[1] ) + self.assertAlmostEqual( 2., result.inverse_lengths[2] ) + self.assertAlmostEqual( 3., result.inverse_lengths[3] ) + self.assertAlmostEqual( 3., result.inverse_lengths[4] ) + self.assertAlmostEqual( 4., result.inverse_lengths[5] ) + self.assertAlmostEqual( 4., result.values[0] ) + self.assertAlmostEqual( 2., result.values[1] ) + self.assertAlmostEqual( 3., result.values[2] ) + self.assertAlmostEqual( 1., result.values[3] ) + self.assertAlmostEqual( 3., result.values[4] ) + self.assertAlmostEqual( 2., result.values[5] ) + self.assertEqual( 1, result.boundaries[0] ) + self.assertEqual( 3, result.boundaries[1] ) + self.assertEqual( 5, result.boundaries[2] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[1] ) + self.assertEqual( InterpolationType.LinearLinear, result.interpolants[2] ) + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 5, linear.number_points ) + self.assertEqual( 2, linear.number_regions ) + + self.assertEqual( 5, len( linear.inverse_lengths ) ) + self.assertEqual( 5, len( linear.values ) ) + self.assertEqual( 2, len( linear.boundaries ) ) + self.assertEqual( 2, len( linear.interpolants ) ) + + self.assertEqual( 1, linear.boundaries[0] ) + self.assertEqual( 4, linear.boundaries[1] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[1] ) + + self.assertAlmostEqual( 1., linear.inverse_lengths[0] ) + self.assertAlmostEqual( 2., linear.inverse_lengths[1] ) + self.assertAlmostEqual( 2., linear.inverse_lengths[2] ) + self.assertAlmostEqual( 3., linear.inverse_lengths[3] ) + self.assertAlmostEqual( 4., linear.inverse_lengths[4] ) + + self.assertAlmostEqual( 4., linear.values[0] ) + self.assertAlmostEqual( 3., linear.values[1] ) + self.assertAlmostEqual( 4., linear.values[2] ) + self.assertAlmostEqual( 3., linear.values[3] ) + self.assertAlmostEqual( 2., linear.values[4] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk3( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_inverse_length_limit ) + self.assertAlmostEqual( 4., chunk.upper_inverse_length_limit ) + self.assertEqual( 4, chunk.number_points ) + self.assertEqual( 2, chunk.number_regions ) + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 3, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( inverse_length = 1. ) ) + self.assertAlmostEqual( 3., chunk( inverse_length = 2. ) ) + self.assertAlmostEqual( 2., chunk( inverse_length = 3. ) ) + self.assertAlmostEqual( 1., chunk( inverse_length = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( inverse_length = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( inverse_length = 5. ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.5, chunk( inverse_length = 1.5 ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 2.44966028678679, chunk( inverse_length = 2.5 ) ) + self.assertAlmostEqual( 1.46416306545103, chunk( inverse_length = 3.5 ) ) + + # verify arithmetic operators throw exceptions + temp = TabulatedScatteringFunction( [ 1., 4. ], [ 4., 1. ] ) + with self.assertRaises( Exception ) : result = -chunk + with self.assertRaises( Exception ) : result = chunk + 2. + with self.assertRaises( Exception ) : result = chunk - 2. + with self.assertRaises( Exception ) : result = chunk * 2. + with self.assertRaises( Exception ) : result = chunk / 2. + with self.assertRaises( Exception ) : result = chunk + temp + with self.assertRaises( Exception ) : result = chunk - temp + with self.assertRaises( Exception ) : chunk += 2. + with self.assertRaises( Exception ) : chunk -= 2. + with self.assertRaises( Exception ) : chunk *= 2. + with self.assertRaises( Exception ) : chunk /= 2. + with self.assertRaises( Exception ) : chunk += temp + with self.assertRaises( Exception ) : chunk -= temp + with self.assertRaises( Exception ) : result = 2. + chunk + with self.assertRaises( Exception ) : result = 2. - chunk + with self.assertRaises( Exception ) : result = 2. * chunk + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 18, linear.number_points ) + self.assertEqual( 1, linear.number_regions ) + + self.assertEqual( 18, len( linear.inverse_lengths ) ) + self.assertEqual( 18, len( linear.values ) ) + self.assertEqual( 1, len( linear.boundaries ) ) + self.assertEqual( 1, len( linear.interpolants ) ) + + self.assertEqual( 17, linear.boundaries[0] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + + self.assertAlmostEqual( 1. , linear.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , linear.inverse_lengths[1] ) + self.assertAlmostEqual( 2.125, linear.inverse_lengths[2] ) + self.assertAlmostEqual( 2.25 , linear.inverse_lengths[3] ) + self.assertAlmostEqual( 2.375, linear.inverse_lengths[4] ) + self.assertAlmostEqual( 2.5 , linear.inverse_lengths[5] ) + self.assertAlmostEqual( 2.625, linear.inverse_lengths[6] ) + self.assertAlmostEqual( 2.75 , linear.inverse_lengths[7] ) + self.assertAlmostEqual( 2.875, linear.inverse_lengths[8] ) + self.assertAlmostEqual( 3. , linear.inverse_lengths[9] ) + self.assertAlmostEqual( 3.125, linear.inverse_lengths[10] ) + self.assertAlmostEqual( 3.25 , linear.inverse_lengths[11] ) + self.assertAlmostEqual( 3.375, linear.inverse_lengths[12] ) + self.assertAlmostEqual( 3.5 , linear.inverse_lengths[13] ) + self.assertAlmostEqual( 3.625, linear.inverse_lengths[14] ) + self.assertAlmostEqual( 3.75 , linear.inverse_lengths[15] ) + self.assertAlmostEqual( 3.875, linear.inverse_lengths[16] ) + self.assertAlmostEqual( 4. , linear.inverse_lengths[17] ) + + self.assertAlmostEqual( 4. , linear.values[0] ) + self.assertAlmostEqual( 3. , linear.values[1] ) + self.assertAlmostEqual( 2.85048128530886, linear.values[2] ) + self.assertAlmostEqual( 2.70951129135145, linear.values[3] ) + self.assertAlmostEqual( 2.57616511633150, linear.values[4] ) + self.assertAlmostEqual( 2.44966028678679, linear.values[5] ) + self.assertAlmostEqual( 2.32932893596581, linear.values[6] ) + self.assertAlmostEqual( 2.21459646033567, linear.values[7] ) + self.assertAlmostEqual( 2.10496492439848, linear.values[8] ) + self.assertAlmostEqual( 2. , linear.values[9] ) + self.assertAlmostEqual( 1.85810031827028, linear.values[10] ) + self.assertAlmostEqual( 1.72176678584324, linear.values[11] ) + self.assertAlmostEqual( 1.59057916034679, linear.values[12] ) + self.assertAlmostEqual( 1.46416306545103, linear.values[13] ) + self.assertAlmostEqual( 1.34218354996644, linear.values[14] ) + self.assertAlmostEqual( 1.22433973930853, linear.values[15] ) + self.assertAlmostEqual( 1.11036036428687, linear.values[16] ) + self.assertAlmostEqual( 1. , linear.values[17] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk4( self, chunk ) : + + # verify content + self.assertAlmostEqual( 1., chunk.lower_inverse_length_limit ) + self.assertAlmostEqual( 4., chunk.upper_inverse_length_limit ) + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + # verify evaluation - values of x in the x grid + self.assertAlmostEqual( 4., chunk( inverse_length = 1. ) ) + self.assertAlmostEqual( 4., chunk( inverse_length = 2. ) ) + self.assertAlmostEqual( 3., chunk( inverse_length = 3. ) ) + self.assertAlmostEqual( 2., chunk( inverse_length = 4. ) ) + + # verify evaluation - values of x outside the x grid + self.assertAlmostEqual( 0.0, chunk( inverse_length = 0. ) ) + self.assertAlmostEqual( 0.0, chunk( inverse_length = 5. ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.5, chunk( inverse_length = 1.5 ) ) + + # verify evaluation - values of x inside the x grid (lin-lin piece) + self.assertAlmostEqual( 3.44966028678679, chunk( inverse_length = 2.5 ) ) + self.assertAlmostEqual( 2.46416306545103, chunk( inverse_length = 3.5 ) ) + + # verify arithmetic operators throw exceptions + temp = TabulatedScatteringFunction( [ 1., 4. ], [ 4., 1. ] ) + with self.assertRaises( Exception ) : result = -chunk + with self.assertRaises( Exception ) : result = chunk + 2. + with self.assertRaises( Exception ) : result = chunk - 2. + with self.assertRaises( Exception ) : result = chunk * 2. + with self.assertRaises( Exception ) : result = chunk / 2. + with self.assertRaises( Exception ) : result = chunk + temp + with self.assertRaises( Exception ) : result = chunk - temp + with self.assertRaises( Exception ) : chunk += 2. + with self.assertRaises( Exception ) : chunk -= 2. + with self.assertRaises( Exception ) : chunk *= 2. + with self.assertRaises( Exception ) : chunk /= 2. + with self.assertRaises( Exception ) : chunk += temp + with self.assertRaises( Exception ) : chunk -= temp + with self.assertRaises( Exception ) : result = 2. + chunk + with self.assertRaises( Exception ) : result = 2. - chunk + with self.assertRaises( Exception ) : result = 2. * chunk + + # verify linearisation + linear = chunk.linearise() + + self.assertEqual( 12, linear.number_points ) + self.assertEqual( 2, linear.number_regions ) + + self.assertEqual( 12, len( linear.inverse_lengths ) ) + self.assertEqual( 12, len( linear.values ) ) + self.assertEqual( 2, len( linear.boundaries ) ) + self.assertEqual( 2, len( linear.interpolants ) ) + + self.assertEqual( 1, linear.boundaries[0] ) + self.assertEqual( 11, linear.boundaries[1] ) + + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLinear, linear.interpolants[1] ) + + self.assertAlmostEqual( 1. , linear.inverse_lengths[0] ) + self.assertAlmostEqual( 2. , linear.inverse_lengths[1] ) + self.assertAlmostEqual( 2. , linear.inverse_lengths[2] ) + self.assertAlmostEqual( 2.125, linear.inverse_lengths[3] ) + self.assertAlmostEqual( 2.25 , linear.inverse_lengths[4] ) + self.assertAlmostEqual( 2.5 , linear.inverse_lengths[5] ) + self.assertAlmostEqual( 2.75 , linear.inverse_lengths[6] ) + self.assertAlmostEqual( 3. , linear.inverse_lengths[7] ) + self.assertAlmostEqual( 3.25 , linear.inverse_lengths[8] ) + self.assertAlmostEqual( 3.5 , linear.inverse_lengths[9] ) + self.assertAlmostEqual( 3.75 , linear.inverse_lengths[10] ) + self.assertAlmostEqual( 4. , linear.inverse_lengths[11] ) + + self.assertAlmostEqual( 4. , linear.values[0] ) + self.assertAlmostEqual( 3. , linear.values[1] ) + self.assertAlmostEqual( 4. , linear.values[2] ) + self.assertAlmostEqual( 3.85048128530886, linear.values[3] ) + self.assertAlmostEqual( 3.70951129135145, linear.values[4] ) + self.assertAlmostEqual( 3.44966028678679, linear.values[5] ) + self.assertAlmostEqual( 3.21459646033567, linear.values[6] ) + self.assertAlmostEqual( 3. , linear.values[7] ) + self.assertAlmostEqual( 2.72176678584324, linear.values[8] ) + self.assertAlmostEqual( 2.46416306545103, linear.values[9] ) + self.assertAlmostEqual( 2.22433973930853, linear.values[10] ) + self.assertAlmostEqual( 2. , linear.values[11] ) + + self.assertEqual( True, linear.is_linearised ) + + def verify_chunk5( self, chunk ) : + + # verify content + self.assertEqual( 5, len( chunk.inverse_lengths ) ) + self.assertEqual( 5, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[3] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[4] ) + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 4., chunk.values[2] ) + self.assertAlmostEqual( 3., chunk.values[3] ) + self.assertAlmostEqual( 2., chunk.values[4] ) + self.assertEqual( 1, chunk.boundaries[0] ) # <-- this is changed from 2 to 1 + self.assertEqual( 4, chunk.boundaries[1] ) + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + def verify_chunk6( self, chunk ) : + + # verify content + self.assertEqual( 4, len( chunk.inverse_lengths ) ) + self.assertEqual( 4, len( chunk.values ) ) + self.assertEqual( 2, len( chunk.boundaries ) ) + self.assertEqual( 2, len( chunk.interpolants ) ) + self.assertAlmostEqual( 1., chunk.inverse_lengths[0] ) + self.assertAlmostEqual( 2., chunk.inverse_lengths[1] ) + self.assertAlmostEqual( 3., chunk.inverse_lengths[2] ) + self.assertAlmostEqual( 4., chunk.inverse_lengths[3] ) # <-- last point removed + self.assertAlmostEqual( 4., chunk.values[0] ) + self.assertAlmostEqual( 3., chunk.values[1] ) + self.assertAlmostEqual( 2., chunk.values[2] ) + self.assertAlmostEqual( 1., chunk.values[3] ) # <-- last point removed + self.assertEqual( 1, chunk.boundaries[0] ) + self.assertEqual( 3, chunk.boundaries[1] ) # <-- boundary value reset + self.assertEqual( InterpolationType.LinearLinear, chunk.interpolants[0] ) + self.assertEqual( InterpolationType.LinearLog, chunk.interpolants[1] ) + self.assertEqual( False, chunk.is_linearised ) + + # the data is given explicitly for data without boundaries + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + interpolant = InterpolationType.LinearLinear ) + + verify_chunk1( self, chunk ) + + # the data is given explicitly for data without boundaries and a jump + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 2., 3., 4. ], + values = [ 4., 3., 4., 3., 2. ], + interpolant = InterpolationType.LinearLinear ) + + verify_chunk2( self, chunk ) + + # the data is given explicitly for data without a jump + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + boundaries = [ 1, 3 ], + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk3( self, chunk ) + + # the data is given explicitly for data with a jump + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 2., 3., 4. ], + values = [ 4., 3., 4., 3., 2. ], + boundaries = [ 1, 4 ], + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk4( self, chunk ) + + # the data is given explicitly with boundaries that point to the second x value in the jump + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 2., 3., 4. ], + values = [ 4., 3., 4., 3., 2. ], + boundaries = [ 2, 4 ], # <-- pointing to end of the jump + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk5( self, chunk ) + + # the data is given explicitly with a jump at the end that goes to zero + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 3., 4., 4. ], # <-- jump at end + values = [ 4., 3., 2., 1., 0. ], # <-- last value is zero + boundaries = [ 1, 4 ], # <-- pointing to end + interpolants = [ InterpolationType.LinearLinear, + InterpolationType.LinearLog ] ) + + verify_chunk6( self, chunk ) + + def test_failures( self ) : + + print( '\n' ) + + # there are not enough values in the x or y grid + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [], values = [] ) + + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1. ], values = [ 4. ] ) + + # the x and y grid do not have the same number of points + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2. ] ) + + # the boundaries and interpolants do not have the same size + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + boundaries = [ 3 ], + interpolants = [] ) + + # the x grid is not sorted + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 3., 2., 4. ], + values = [ 4., 3., 2., 1. ] ) + + # the x grid contains a triple x value + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 2., 2., 3., 4. ], + values = [ 4., 3., 3., 3., 2., 1. ] ) + + # the x grid has a jump at the beginning + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 1., 3., 4. ], + values = [ 4., 3., 1., 4. ] ) + + # the x grid has a jump at the end + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 4., 4. ], + values = [ 4., 3., 1., 4. ] ) + + # the last boundary does not point to the last point + with self.assertRaises( Exception ) : + + chunk = TabulatedScatteringFunction( inverse_lengths = [ 1., 2., 3., 4. ], + values = [ 4., 3., 2., 1. ], + boundaries = [ 2 ], + interpolants = [ InterpolationType.LinearLinear ] ) + +if __name__ == '__main__' : + + unittest.main()