Ejemplo n.º 1
0
    def ccc_initialize(self, call_tc=False):
        '''
        ParametersBase reads JSON file and sets attributes to self
        Next call self.compute_default_params for further initialization

        Args:
            call_tc (bool): whether to use Tax-Calculator to estimate
                marginal tax rates

        Returns:
            None

        '''
        if call_tc:
            # Find individual income tax rates from Tax-Calculator
            indiv_rates = get_rates(self.baseline, self.year,
                                    self.iit_reform, self.data)
            self.tau_nc = indiv_rates['tau_nc']
            self.tau_div = indiv_rates['tau_div']
            self.tau_int = indiv_rates['tau_int']
            self.tau_scg = indiv_rates['tau_scg']
            self.tau_lcg = indiv_rates['tau_lcg']
            self.tau_td = indiv_rates['tau_td']
            self.tau_h = indiv_rates['tau_h']
        # does cheap calculations to find parameter values
        self.compute_default_params()
Ejemplo n.º 2
0
def test_get_rates():
    '''
    Test of the get_rates() functions
    '''
    p = Specification()  # has default tax rates, with should equal TC
    test_dict = tc.get_rates(baseline=False,
                             start_year=2019,
                             reform={},
                             data='cps')
    for k, v in test_dict.items():
        assert (np.allclose(v, p.__dict__[k]))
Ejemplo n.º 3
0
    def __init__(self, test=False, time_path=True, baseline=False,
                 year=DEFAULT_START_YEAR, call_tc=False, iit_reform={},
                 data='cps'):
        super(Specifications, self).__init__()

        # reads in default parameter values
        self._vals = self._params_dict_from_json_file()

        self.test = test
        self.baseline = baseline
        self.year = year
        self.iit_reform = iit_reform
        self.data = data

        # put Cost-of-Capital-Calculator version in parameters to save
        # for reference
        self.ccc_version = pkg_resources.get_distribution("ccc").version

        if call_tc:
            # Find individual income tax rates from Tax-Calculator
            indiv_rates = get_rates(self.baseline, self.year,
                                    self.iit_reform, self.data)
        else:
            # Set indiv rates to some values
            indiv_rates = {'tau_nc': np.array([0.1929392]),
                           'tau_div': np.array([0.1882453]),
                           'tau_int': np.array([0.31239301]),
                           'tau_scg': np.array([0.29068557]),
                           'tau_lcg': np.array([0.18837299]),
                           'tau_td': np.array([0.21860396]),
                           'tau_h': np.array([0.04376291])}
        self.tau_nc = indiv_rates['tau_nc']
        self.tau_div = indiv_rates['tau_div']
        self.tau_int = indiv_rates['tau_int']
        self.tau_scg = indiv_rates['tau_scg']
        self.tau_lcg = indiv_rates['tau_lcg']
        self.tau_xcg = 0.00  # tax rate on capital gains held to death
        self.tau_td = indiv_rates['tau_td']
        self.tau_h = indiv_rates['tau_h']

        # does cheap calculations to find parameter values
        self.initialize()

        self.parameter_warnings = ''
        self.parameter_errors = ''
        self._ignore_errors = False
Ejemplo n.º 4
0
 def initialize(self, call_tc=False):
     """
     ParametersBase reads JSON file and sets attributes to self
     Next call self.compute_default_params for further initialization
     Parameters:
     -----------
     run_micro: boolean that indicates whether to estimate tax funtions
             from microsim model
     """
     if call_tc:
         # Find individual income tax rates from Tax-Calculator
         indiv_rates = get_rates(self.baseline, self.year, self.iit_reform,
                                 self.data)
         self.tau_nc = indiv_rates['tau_nc']
         self.tau_div = indiv_rates['tau_div']
         self.tau_int = indiv_rates['tau_int']
         self.tau_scg = indiv_rates['tau_scg']
         self.tau_lcg = indiv_rates['tau_lcg']
         self.tau_xcg = 0.00  # tax rate on capital gains held to death
         self.tau_td = indiv_rates['tau_td']
         self.tau_h = indiv_rates['tau_h']
     # does cheap calculations to find parameter values
     self.compute_default_params()
def test_tc_start_year(year):
    '''
    Test that different start years work in functions calling
    Tax-Calculator
    '''
    get_rates(True, year)
Ejemplo n.º 6
0
    def compute_default_params(self):
        """
        Does cheap calculations to return parameter values
        """
        # Find individual income tax rates from Tax-Calculator
        # maybe have an if statement to go to tax-calc?
        indiv_rates = get_rates(self.baseline, self.start_year,
                                self.iit_reform, self.data)
        self.tau_nc = indiv_rates['tau_nc']
        self.tau_div = indiv_rates['tau_div']
        self.tau_int = indiv_rates['tau_int']
        self.tau_scg = indiv_rates['tau_scg']
        self.tau_lcg = indiv_rates['tau_lcg']
        self.tau_xcg = 0.00  # tax rate on capital gains held to death
        self.tau_td = indiv_rates['tau_td']
        self.tau_h = indiv_rates['tau_h']

        u_c = self.CIT_rate
        if not self.PT_entity_tax_ind:
            u_nc = self.tau_nc
        else:
            u_nc = self.PT_entity_tax_rate
        self.u_array = np.array([u_c, u_nc])

        sprime_c_td = ((1 / self.Y_td) * np.log((
            (1 - self.tau_td) *
            np.exp(self.nominal_interest_rate * self.Y_td)) + self.tau_td) -
                       self.inflation_rate)
        s_c_d_td = (self.gamma *
                    (self.nominal_interest_rate - self.inflation_rate) +
                    (1 - self.gamma) * sprime_c_td)
        s_c_d = (self.alpha_c_d_ft *
                 (((1 - self.tau_int) * self.nominal_interest_rate) -
                  self.inflation_rate) + self.alpha_c_d_td * s_c_d_td +
                 self.alpha_c_d_nt *
                 (self.nominal_interest_rate - self.inflation_rate))
        s_nc_d_td = s_c_d_td
        s_nc_d = (self.alpha_nc_d_ft *
                  (((1 - self.tau_int) * self.nominal_interest_rate) -
                   self.inflation_rate) + self.alpha_nc_d_td * s_nc_d_td +
                  self.alpha_nc_d_nt *
                  (self.nominal_interest_rate - self.inflation_rate))

        g_scg = ((1 / self.Y_scg) * np.log(((1 - self.tau_scg) * np.exp(
            (self.inflation_rate + self.m * self.E_c) * self.Y_scg)) +
                                           self.tau_scg) - self.inflation_rate)
        g_lcg = ((1 / self.Y_lcg) * np.log(((1 - self.tau_lcg) * np.exp(
            (self.inflation_rate + self.m * self.E_c) * self.Y_lcg)) +
                                           self.tau_lcg) - self.inflation_rate)
        g = (self.omega_scg * g_scg + self.omega_lcg * g_lcg +
             self.omega_xcg * self.m * self.E_c)
        s_c_e_ft = (1 - self.m) * self.E_c * (1 - self.tau_div) + g
        s_c_e_td = ((1 / self.Y_td) * np.log(((1 - self.tau_td) * np.exp(
            (self.inflation_rate + self.E_c) * self.Y_td)) + self.tau_td) -
                    self.inflation_rate)
        s_c_e = (self.alpha_c_e_ft * s_c_e_ft + self.alpha_c_e_td * s_c_e_td +
                 self.alpha_c_e_nt * self.E_c)

        s_c = self.f_c * s_c_d + (1 - self.f_c) * s_c_e

        E_nc = s_c_e
        E_array = np.array([self.E_c, E_nc])
        s_nc_e = E_nc
        s_nc = self.f_nc * s_nc_d + (1 - self.f_nc) * s_nc_e
        s_array = np.array([[s_c, s_nc], [s_c_d, s_nc_d], [s_c_e, s_nc_e]])
        f_array = np.array([[self.f_c, self.f_nc], [1, 1], [0, 0]])
        ace_array = np.array([self.ace, self.ace_nc])
        r = (
            f_array * (self.nominal_interest_rate *
                       (1 - (1 - self.int_haircut) * self.u_array)) +
            (1 - f_array) *
            (E_array + self.inflation_rate - E_array * self.r_ace * ace_array))
        r_prime = (f_array * self.nominal_interest_rate + (1 - f_array) *
                   (E_array + self.inflation_rate))

        # if no entity level taxes on pass-throughs, ensure mettr and metr
        # on non-corp entities the same
        if not self.PT_entity_tax_ind:
            r_prime[:, 1] = s_array[:, 1] + self.inflation_rate
        # If entity level tax, assume distribute earnings at same rate corps
        # distribute dividends and these are taxed at dividends tax rate
        # (which seems likely).  Also implicitly assumed that if entity
        # level tax, then only additional taxes on pass-through income are
        # capital gains and dividend taxes
        else:
            # keep debt and equity financing ratio the same even though now
            # entity level tax that might now favor debt
            s_array[0, 1] = self.f_nc * s_nc_d + (1 - self.f_nc) * s_c_e
            s_array[2, 1] = s_c_e
        self.delta = get_econ_depr()
        self.tax_methods = {
            'DB 200%': 2.0,
            'DB 150%': 1.5,
            'SL': 1.0,
            'Economic': 1.0,
            'Expensing': 1.0
        }
        self.financing_list = ['', '_d', '_e']
        self.entity_list = ['_c', '_nc']

        # Create dictionaries with depreciation system and rate of bonus
        # depreciation by asset class
        class_list = [3, 5, 7, 10, 15, 20, 25, 27.5, 39]
        class_list_str = [(str(i) if i != 27.5 else '27_5')
                          for i in class_list]
        self.deprec_system = {}
        self.bonus_deprec = {}
        for cl in class_list_str:
            self.deprec_system[cl] = getattr(self,
                                             'DeprecSystem_{}yr'.format(cl))
            self.bonus_deprec[cl] = getattr(self,
                                            'BonusDeprec_{}yr'.format(cl))
        tax_methods = {
            'DB 200%': 2.0,
            'DB 150%': 1.5,
            'SL': 1.0,
            'Economic': 1.0,
            'Expensing': 1.0
        }
        self.financing_list = ['', '_d', '_e']
        self.entity_list = ['_c', '_nc']
        self.z = calc_tax_depr_rates(r, self.inflation_rate, self.delta,
                                     self.bonus_deprec, self.deprec_system,
                                     self.inventory_expensing,
                                     self.land_expensing, tax_methods,
                                     self.financing_list, self.entity_list)