[lmi-commits] [5707] Calculate loads with maximum as well as minimum premium tax

[Greg Chicares]

Revision: 5707
          http://svn.sv.gnu.org/viewvc/?view=rev&root=lmi&revision=5707
Author:   chicares
Date:     2013-04-19 14:09:17 +0000 (Fri, 19 Apr 2013)
Log Message:
-----------
Calculate loads with maximum as well as minimum premium tax

Modified Paths:
--------------
    lmi/trunk/loads.cpp
    lmi/trunk/loads.hpp
    lmi/trunk/loads_impl.hpp
    lmi/trunk/loads_test.cpp

Modified: lmi/trunk/loads.cpp
===================================================================
--- lmi/trunk/loads.cpp 2013-04-19 13:46:17 UTC (rev 5706)
+++ lmi/trunk/loads.cpp 2013-04-19 14:09:17 UTC (rev 5707)
@@ -56,6 +56,7 @@
         (length
         ,V.yare_input_.AmortizePremiumLoad
         ,V.PremiumTax_->load_rate()
+        ,V.PremiumTax_->maximum_load_rate()
         ,V.PremiumTax_->minimum_load_rate()
         ,V.PremiumTax_->levy_rate()
         ,V.Database_->Query(DB_PremTaxAmortIntRate)
@@ -115,6 +116,8 @@
 
     target_premium_load_excluding_premium_tax_.resize(length);
     excess_premium_load_excluding_premium_tax_.resize(length);
+    target_premium_load_maximum_premium_tax_  .resize(length);
+    excess_premium_load_maximum_premium_tax_  .resize(length);
     target_premium_load_minimum_premium_tax_  .resize(length);
     excess_premium_load_minimum_premium_tax_  .resize(length);
 }
@@ -251,6 +254,8 @@
         if(mce_gen_curr == j)
             {
             target_premium_load_excluding_premium_tax_ = target_total_load_[j];
+            target_premium_load_maximum_premium_tax_   = target_total_load_[j];
+            target_premium_load_maximum_premium_tax_  += 
details.maximum_premium_tax_load_rate_;
             target_premium_load_minimum_premium_tax_   = target_total_load_[j];
             target_premium_load_minimum_premium_tax_  += 
details.minimum_premium_tax_load_rate_;
             }
@@ -262,6 +267,8 @@
         if(mce_gen_curr == j)
             {
             excess_premium_load_excluding_premium_tax_ = excess_total_load_[j];
+            excess_premium_load_maximum_premium_tax_   = excess_total_load_[j];
+            excess_premium_load_maximum_premium_tax_  += 
details.maximum_premium_tax_load_rate_;
             excess_premium_load_minimum_premium_tax_   = excess_total_load_[j];
             excess_premium_load_minimum_premium_tax_  += 
details.minimum_premium_tax_load_rate_;
             }

Modified: lmi/trunk/loads.hpp
===================================================================
--- lmi/trunk/loads.hpp 2013-04-19 13:46:17 UTC (rev 5706)
+++ lmi/trunk/loads.hpp 2013-04-19 14:09:17 UTC (rev 5707)
@@ -68,6 +68,8 @@
 
     std::vector<double> const& target_premium_load_excluding_premium_tax() 
const;
     std::vector<double> const& excess_premium_load_excluding_premium_tax() 
const;
+    std::vector<double> const& target_premium_load_maximum_premium_tax() const;
+    std::vector<double> const& excess_premium_load_maximum_premium_tax() const;
     std::vector<double> const& target_premium_load_minimum_premium_tax() const;
     std::vector<double> const& excess_premium_load_minimum_premium_tax() const;
 
@@ -99,6 +101,8 @@
 
     std::vector<double> target_premium_load_excluding_premium_tax_;
     std::vector<double> excess_premium_load_excluding_premium_tax_;
+    std::vector<double> target_premium_load_maximum_premium_tax_;
+    std::vector<double> excess_premium_load_maximum_premium_tax_;
     std::vector<double> target_premium_load_minimum_premium_tax_;
     std::vector<double> excess_premium_load_minimum_premium_tax_;
 };
@@ -200,6 +204,18 @@
 }
 
 inline std::vector<double> const&
+Loads::target_premium_load_maximum_premium_tax() const
+{
+    return target_premium_load_maximum_premium_tax_;
+}
+
+inline std::vector<double> const&
+Loads::excess_premium_load_maximum_premium_tax() const
+{
+    return excess_premium_load_maximum_premium_tax_;
+}
+
+inline std::vector<double> const&
 Loads::target_premium_load_minimum_premium_tax() const
 {
     return target_premium_load_minimum_premium_tax_;

Modified: lmi/trunk/loads_impl.hpp
===================================================================
--- lmi/trunk/loads_impl.hpp    2013-04-19 13:46:17 UTC (rev 5706)
+++ lmi/trunk/loads_impl.hpp    2013-04-19 14:09:17 UTC (rev 5707)
@@ -46,6 +46,10 @@
 ///
 /// premium_tax_load_: Scalar premium-tax load (zero if tiered).
 ///
+/// maximum_premium_tax_load_rate_: The highest rate of premium tax.
+/// Products that pass premium tax through as a load need this for
+/// pay-as-you-go premiums. The actual rate may differ if tiered.
+///
 /// minimum_premium_tax_load_rate_: The lowest rate of premium tax.
 /// Products that pass premium tax through as a load need this for
 /// 7702 calculations. The actual rate may differ if tiered.
@@ -84,6 +88,7 @@
         (int                        length
         ,bool                       AmortizePremLoad
         ,double                     premium_tax_load
+        ,double                     maximum_premium_tax_load_rate
         ,double                     minimum_premium_tax_load_rate
         ,double                     premium_tax_rate
         ,double                     premium_tax_amortization_rate
@@ -100,6 +105,7 @@
         :length_                          (length)
         ,AmortizePremLoad_                (AmortizePremLoad)
         ,premium_tax_load_                (premium_tax_load)
+        ,maximum_premium_tax_load_rate_   (maximum_premium_tax_load_rate)
         ,minimum_premium_tax_load_rate_   (minimum_premium_tax_load_rate)
         ,premium_tax_rate_                (premium_tax_rate)
         ,premium_tax_amortization_rate_   (premium_tax_amortization_rate)
@@ -117,6 +123,7 @@
     int                        length_;
     bool                       AmortizePremLoad_;
     double                     premium_tax_load_;
+    double                     maximum_premium_tax_load_rate_;
     double                     minimum_premium_tax_load_rate_;
     double                     premium_tax_rate_;
     double                     premium_tax_amortization_rate_;

Modified: lmi/trunk/loads_test.cpp
===================================================================
--- lmi/trunk/loads_test.cpp    2013-04-19 13:46:17 UTC (rev 5706)
+++ lmi/trunk/loads_test.cpp    2013-04-19 14:09:17 UTC (rev 5707)
@@ -63,6 +63,7 @@
 #include "premium_tax.hpp"
 double premium_tax::levy_rate        () const {return 0.0;}
 double premium_tax::load_rate        () const {return 0.0;}
+double premium_tax::maximum_load_rate() const {return 0.0;}
 double premium_tax::minimum_load_rate() const {return 0.0;}
 
 struct LoadsTest
@@ -122,6 +123,8 @@
     INVOKE_BOOST_TEST_EQUAL(z, loads_.dac_tax_load                             
().size(), file, line);
     INVOKE_BOOST_TEST_EQUAL(z, 
loads_.target_premium_load_excluding_premium_tax().size(), file, line);
     INVOKE_BOOST_TEST_EQUAL(z, 
loads_.excess_premium_load_excluding_premium_tax().size(), file, line);
+    INVOKE_BOOST_TEST_EQUAL(z, loads_.target_premium_load_maximum_premium_tax  
().size(), file, line);
+    INVOKE_BOOST_TEST_EQUAL(z, loads_.excess_premium_load_maximum_premium_tax  
().size(), file, line);
     INVOKE_BOOST_TEST_EQUAL(z, loads_.target_premium_load_minimum_premium_tax  
().size(), file, line);
     INVOKE_BOOST_TEST_EQUAL(z, loads_.excess_premium_load_minimum_premium_tax  
().size(), file, line);
 
@@ -188,6 +191,8 @@
     INVOKE_BOOST_TEST(materially_equal(0.103000, loads_.excess_total_load     
(mce_gen_curr)[0]), file, line);
     INVOKE_BOOST_TEST(materially_equal(0.142000, 
loads_.target_premium_load_excluding_premium_tax()[0]), file, line);
     INVOKE_BOOST_TEST(materially_equal(0.082000, 
loads_.excess_premium_load_excluding_premium_tax()[0]), file, line);
+    INVOKE_BOOST_TEST(materially_equal(0.164000, 
loads_.target_premium_load_maximum_premium_tax  ()[0]), file, line);
+    INVOKE_BOOST_TEST(materially_equal(0.104000, 
loads_.excess_premium_load_maximum_premium_tax  ()[0]), file, line);
     INVOKE_BOOST_TEST(materially_equal(0.162000, 
loads_.target_premium_load_minimum_premium_tax  ()[0]), file, line);
     INVOKE_BOOST_TEST(materially_equal(0.102000, 
loads_.excess_premium_load_minimum_premium_tax  ()[0]), file, line);
 }
@@ -205,6 +210,7 @@
         (length                 // length_
         ,false                  // AmortizePremLoad_
         ,0.021                  // premium_tax_load_
+        ,0.022                  // maximum_premium_tax_load_rate_
         ,0.02                   // minimum_premium_tax_load_rate_
         ,999.999                // premium_tax_rate_                [unused]
         ,999.999                // premium_tax_amortization_rate_   [unused]