'''
Created on 20-Jan-2022

@author: bthakur
'''

import os
import codecs
import inspect
import traceback
import random

from xv.util import UtilClass

# _arithmetic_helper
# ArithmeticHelper

class ArithmeticHelper(UtilClass):
    
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self._arithmetic_expression_helper = None
        self._arithmetic_expression_solver = None
        self._arithmetic_grid_helper = None
        self._arithmetic_operation_helper = None
        self._arithmetic_walk_helper = None

        self._decimal_operation_helper = None

        self._elementary_integer_helper = None

        self._fast_arithmetic_helper = None
        self._fast_calculation_helper = None
        
        self._integer_properties_helper = None
        self._inequality_grid_helper = None
        self._irrational_operation_helper = None

        self._lcm_hcf_helper = None
        self._logarithm_helper = None
        self._long_arithmetic_process_helper = None
        

        self._profit_loss_helper = None
        self._prime_number_helper = None
        self._positional_value_helper = None
        self._power_helper = None
        self._advanced_power_helper = None
        self._divisibility_helper = None

        self._rational_number_helper = None
        self._irrational_number_helper = None
        self._rational_operation_helper = None
        self._ratio_helper = None
        
        self._series_pattern_helper = None
        
        
        self._kwargs = kwargs
        pass

    def get_arithmetic_operation_helper(self):
        if self._arithmetic_operation_helper is None:
            self._init_arithmetic_operation_helper(**self._kwargs)
        return self._arithmetic_operation_helper
        pass

    def _init_arithmetic_operation_helper(self, **kwargs):  
        from ._arithmetic_operation_helper import ArithmeticOperationHelper
        self._arithmetic_operation_helper = ArithmeticOperationHelper(**kwargs) 
        pass
   

    def get_arithmetic_expression_solver(self):
        if self._arithmetic_expression_solver is None:
            self._init_arithmetic_expression_solver(**self._kwargs)
        return self._arithmetic_expression_solver
        pass

    def _init_arithmetic_expression_solver(self, **kwargs):  
        from ._arithmetic_expression_solver import ArithmeticExpressionSolver
        self._arithmetic_expression_solver = ArithmeticExpressionSolver(**kwargs) 
        pass
   
            

    def get_arithmetic_grid_helper(self):
        if self._arithmetic_grid_helper is None:
            self._init_arithmetic_grid_helper(**self._kwargs)
        return self._arithmetic_grid_helper
        pass

    def _init_arithmetic_grid_helper(self, **kwargs):  
        from ._arithmetic_grid_helper import ArithmeticGridHelper
        self._arithmetic_grid_helper = ArithmeticGridHelper(**kwargs) 
        pass
    


    def get_arithmetic_expression_helper(self):
        if self._arithmetic_expression_helper is None:
            self._init_arithmetic_expression_helper(**self._kwargs)
        return self._arithmetic_expression_helper
        pass

    def _init_arithmetic_expression_helper(self, **kwargs):  
        from ._arithmetic_expression_helper import ArithmeticExpressionHelper
        self._arithmetic_expression_helper = ArithmeticExpressionHelper(**kwargs) 
        pass




    def get_arithmetic_walk_helper(self):
        if self._arithmetic_walk_helper is None:
            self._init_arithmetic_walk_helper(**self._kwargs)
        return self._arithmetic_walk_helper
        pass

    def _init_arithmetic_walk_helper(self, **kwargs):  
        from ._arithmetic_walk_helper import ArithmeticWalkHelper
        self._arithmetic_walk_helper = ArithmeticWalkHelper(**kwargs) 
        pass


    def get_decimal_operation_helper(self):
        if self._decimal_operation_helper is None:
            self._init_decimal_operation_helper(**self._kwargs)
        return self._decimal_operation_helper
        pass

    def _init_decimal_operation_helper(self, **kwargs):  
        from ._decimal_operation_helper import DecimalOperationHelper
        self._decimal_operation_helper = DecimalOperationHelper(**kwargs) 
        pass



    def get_elementary_integer_helper(self):
        if self._elementary_integer_helper is None:
            self._init_elementary_integer_helper(**self._kwargs)
        return self._elementary_integer_helper
        pass

    def _init_elementary_integer_helper(self, **kwargs):  
        from ._elementary_integer_helper import ElementaryIntegerHelper
        self._elementary_integer_helper = ElementaryIntegerHelper(**kwargs) 
        pass
    

    def get_fast_arithmetic_helper(self):
        if self._fast_arithmetic_helper is None:
            self._init_fast_arithmetic_helper(**self._kwargs)
        return self._fast_arithmetic_helper
        pass


    def _init_fast_arithmetic_helper(self, **kwargs):  
        from ._fast_arithmetic_helper import FastArithmeticHelper
        self._fast_arithmetic_helper = FastArithmeticHelper(**kwargs) 
        pass

    def get_fast_calculation_helper(self):
        if self._fast_calculation_helper is None:
            self._init_fast_calculation_helper(**self._kwargs)
        return self._fast_calculation_helper
        pass

    def _init_fast_calculation_helper(self, **kwargs):  
        from ._fast_calculation_helper import FastCalculationHelper
        self._fast_calculation_helper = FastCalculationHelper(**kwargs) 
        pass


    def get_integer_properties_helper(self):
        if self._integer_properties_helper is None:
            self._init_integer_properties_helper(**self._kwargs)
        return self._integer_properties_helper
        pass

    def _init_integer_properties_helper(self, **kwargs):  
        from ._integer_properties_helper import IntegerPropertiesHelper
        self._integer_properties_helper = IntegerPropertiesHelper(**kwargs) 
        pass
   
   
    def get_irrational_operation_helper(self):
        if self._irrational_operation_helper is None:
            self._init_irrational_operation_helper(**self._kwargs)
        return self._irrational_operation_helper
        pass

    def _init_irrational_operation_helper(self, **kwargs):  
        from ._irrational_operation_helper import IrrationalOperationHelper
        self._irrational_operation_helper = IrrationalOperationHelper(**kwargs) 
        pass
            

    def get_inequality_grid_helper(self):
        if self._inequality_grid_helper is None:
            self._init_inequality_grid_helper(**self._kwargs)
        return self._inequality_grid_helper
        pass

    def _init_inequality_grid_helper(self, **kwargs):  
        from ._inequality_grid_helper import InequalityGridHelper
        self._inequality_grid_helper = InequalityGridHelper(**kwargs) 
        pass


    def get_lcm_hcf_helper(self):
        if self._lcm_hcf_helper is None:
            self._init_lcm_hcf_helper(**self._kwargs)
        return self._lcm_hcf_helper
        pass

    def _init_lcm_hcf_helper(self, **kwargs):  
        from ._lcm_hcf_helper import LcmHcfHelper
        self._lcm_hcf_helper = LcmHcfHelper(**kwargs) 
        pass

   
    def get_logarithm_helper(self):
        if self._logarithm_helper is None:
            self._init_logarithm_helper(**self._kwargs)
        return self._logarithm_helper
        pass

    def _init_logarithm_helper(self, **kwargs):  
        from ._logarithm_helper import LogarithmHelper
        self._logarithm_helper = LogarithmHelper(**kwargs) 
        pass


    def get_long_arithmetic_process_helper(self):
        if self._long_arithmetic_process_helper is None:
            self._init_long_arithmetic_process_helper(**self._kwargs)
        return self._long_arithmetic_process_helper
        pass

    def _init_long_arithmetic_process_helper(self, **kwargs):  
        from ._long_arithmetic_process_helper import LongArithmeticProcessHelper
        self._long_arithmetic_process_helper = LongArithmeticProcessHelper(**kwargs) 
        pass



    def get_profit_loss_helper(self):
        if self._profit_loss_helper is None:
            self._init_profit_loss_helper(**self._kwargs)
        return self._profit_loss_helper
        pass

    def _init_profit_loss_helper(self, **kwargs):  
        from ._profit_loss_helper import ProfitLossHelper
        self._profit_loss_helper = ProfitLossHelper(**kwargs) 
        pass
   


    def get_positional_value_helper(self):
        if self._positional_value_helper is None:
            self._init_positional_value_helper(**self._kwargs)
        return self._positional_value_helper
        pass

    def _init_positional_value_helper(self, **kwargs):  
        from ._positional_value_helper import PositionalValueHelper
        self._positional_value_helper = PositionalValueHelper(**kwargs) 
        pass

    def get_prime_number_helper(self):
        if self._prime_number_helper is None:
            self._init_prime_number_helper(**self._kwargs)
        return self._prime_number_helper
        pass

    def _init_prime_number_helper(self, **kwargs):  
        from ._prime_number_helper import PrimeNumberHelper
        self._prime_number_helper = PrimeNumberHelper(**kwargs) 
        pass
    
    
    
    def get_power_helper(self):
        if self._power_helper is None:
            self._init_power_helper(**self._kwargs)
        return self._power_helper
        pass

    def _init_power_helper(self, **kwargs):  
        from ._power_helper import PowerHelper
        self._power_helper = PowerHelper(**kwargs) 
        pass


    def get_advanced_power_helper(self):
        if self._advanced_power_helper is None:
            self._init_advanced_power_helper(**self._kwargs)
        return self._advanced_power_helper
        pass

    def _init_advanced_power_helper(self, **kwargs):  
        from ._advanced_power_helper import AdvancedPowerHelper
        self._advanced_power_helper = AdvancedPowerHelper(**kwargs) 
        pass


    def get_divisibility_helper(self):
        if self._divisibility_helper is None:
            self._init_divisibility_helper(**self._kwargs)
        return self._divisibility_helper
        pass

    def _init_divisibility_helper(self, **kwargs):  
        from ._divisibility_helper import DivisibilityHelper
        self._divisibility_helper = DivisibilityHelper(**kwargs) 
        pass


    def get_ratio_helper(self):
        if self._ratio_helper is None:
            self._init_ratio_helper(**self._kwargs)
        return self._ratio_helper
        pass

    def _init_ratio_helper(self, **kwargs):  
        from ._ratio_helper import RatioHelper
        self._ratio_helper = RatioHelper(**kwargs) 
        pass
   

    def get_rational_operation_helper(self):
        if self._arithmetic_expression_helper is None:
            self._init_rational_operation_helper(**self._kwargs)
        return self._arithmetic_expression_helper
        pass

    def _init_rational_operation_helper(self, **kwargs):  
        from ._rational_operation_helper import RationalOperationHelper
        self._arithmetic_expression_helper = RationalOperationHelper(**kwargs) 
        pass

        
    def get_rational_number_helper(self):
        if self._rational_number_helper is None:
            self._init_rational_number_helper(**self._kwargs)
        return self._rational_number_helper
        pass

    def _init_rational_number_helper(self, **kwargs):  
        from ._rational_number_helper import RationalNumberHelper
        self._rational_number_helper = RationalNumberHelper(**kwargs) 
        pass

    def get_irrational_number_helper(self):
        if self._irrational_number_helper is None:
            self._init_irrational_number_helper(**self._kwargs)
        return self._irrational_number_helper
        pass

    def _init_irrational_number_helper(self, **kwargs):  
        from ._irrational_number_helper import IrrationalNumberHelper
        self._irrational_number_helper = IrrationalNumberHelper(**kwargs) 
        pass


    def get_series_pattern_helper(self):
        if self._series_pattern_helper is None:
            self._init_series_pattern_helper(**self._kwargs)
        return self._series_pattern_helper
        pass

    def _init_series_pattern_helper(self, **kwargs):  
        from ._series_pattern_helper import SeriesPatternHelper
        self._series_pattern_helper = SeriesPatternHelper(**kwargs) 
        pass
   
    pass
#class ArithmeticHelper:
