'''
Created on 20-Jan-2022

@author: bthakur
'''

import os
import codecs
import inspect
import traceback
import random

from xv.util import UtilClass

# _calculus_helper
# CalculusHelper


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

        self._curve_length_helper = None
        self._surface_area_of_rotation_helper = None
        self._area_under_curve_helper = None
        self._std_differentiation_helper = None
        self._std_integration_helper = None
        self._auto_derivation_calc_helper = None

        self._differential_equation_helper = None
        self._applied_differentiation_helper = None
        self._differentiation_basics_helper = None
        self._differentiation_theory_helper = None

        self._integration_helper = None

        self._jacobian_helper = None

        self._lhopitals_helper = None
        self._limit_helper = None
        self._working_helper = None

        self._max_min_helper = None
        
        self._kwargs = kwargs
        pass


    def get_curve_length_helper(self):
        if self._curve_length_helper is None:
            self._init_curve_length_helper(**self._kwargs)
        return self._curve_length_helper
        pass

    def _init_curve_length_helper(self, **kwargs):  
        from ._curve_length_helper import CurveLengthHelper
        self._curve_length_helper = CurveLengthHelper(**kwargs) 
        pass
   

    def get_surface_area_of_rotation_helper(self):
        if self._surface_area_of_rotation_helper is None:
            self._init_surface_area_of_rotation_helper(**self._kwargs)
        return self._surface_area_of_rotation_helper
        pass

    def _init_surface_area_of_rotation_helper(self, **kwargs):  
        from ._surface_area_of_rotation_helper import SurfaceAreaOfRotationHelper
        self._surface_area_of_rotation_helper = SurfaceAreaOfRotationHelper(**kwargs) 
        pass
   


    def get_area_under_curve_helper(self):
        if self._area_under_curve_helper is None:
            self._init_area_under_curve_helper(**self._kwargs)
        return self._area_under_curve_helper
        pass

    def _init_area_under_curve_helper(self, **kwargs):  
        from ._area_under_curve_helper import AreaUnderCurveHelper
        self._area_under_curve_helper = AreaUnderCurveHelper(**kwargs) 
        pass
   
   
   

    def get_std_differentiation_helper(self):
        if self._std_differentiation_helper is None:
            self._init_std_differentiation_helper(**self._kwargs)
        return self._std_differentiation_helper
        pass

    def _init_std_differentiation_helper(self, **kwargs):  
        from ._std_differentiation_helper import StdDifferentiationHelper
        self._std_differentiation_helper = StdDifferentiationHelper(**kwargs) 
        pass
   
  

    def get_std_integration_helper(self):
        if self._std_integration_helper is None:
            self._init_std_integration_helper(**self._kwargs)
        return self._std_integration_helper
        pass

    def _init_std_integration_helper(self, **kwargs):  
        from ._std_integration_helper import StdIntegrationHelper
        self._std_integration_helper = StdIntegrationHelper(**kwargs) 
        pass
   

    def get_auto_derivation_calc_helper(self):
        if self._auto_derivation_calc_helper is None:
            self._init_auto_derivation_calc_helper(**self._kwargs)
        return self._auto_derivation_calc_helper
        pass

    def _init_auto_derivation_calc_helper(self, **kwargs):  
        from ._auto_derivation_calc_helper import AutoDerivationCalcHelper
        self._auto_derivation_calc_helper = AutoDerivationCalcHelper(**kwargs) 
        pass
   
    def get_differential_equation_helper(self):
        if self._differential_equation_helper is None:
            self._init_differential_equation_helper(**self._kwargs)
        return self._differential_equation_helper
        pass

    def _init_differential_equation_helper(self, **kwargs):  
        from ._differential_equation_helper import DifferentialEquationHelper
        self._differential_equation_helper = DifferentialEquationHelper(**kwargs) 
        pass
   



    def get_applied_differentiation_helper(self):
        if self._applied_differentiation_helper is None:
            self._init_applied_differentiation_helper(**self._kwargs)
        return self._applied_differentiation_helper
        pass

    def _init_applied_differentiation_helper(self, **kwargs):  
        from ._applied_differentiation_helper import AppliedDifferentiationHelper
        self._applied_differentiation_helper = AppliedDifferentiationHelper(**kwargs) 
        pass

    def get_differentiation_basics_helper(self):
        if self._differentiation_basics_helper is None:
            self._init_differentiation_basics_helper(**self._kwargs)
        return self._differentiation_basics_helper
        pass

    def _init_differentiation_basics_helper(self, **kwargs):  
        from ._differentiation_basics_helper import DifferentiationBasicsHelper
        self._differentiation_basics_helper = DifferentiationBasicsHelper(**kwargs) 
        pass
   

   
    def get_differentiation_theory_helper(self):
        if self._differentiation_theory_helper is None:
            self._init_differentiation_theory_helper(**self._kwargs)
        return self._differentiation_theory_helper
        pass

    def _init_differentiation_theory_helper(self, **kwargs):  
        from ._differentiation_theory_helper import DifferentiationTheoryHelper
        self._differentiation_theory_helper = DifferentiationTheoryHelper(**kwargs) 
        pass
   


    def get_integration_helper(self):
        if self._integration_helper is None:
            self._init_integration_helper(**self._kwargs)
        return self._integration_helper
        pass

    def _init_integration_helper(self, **kwargs):  
        from ._integration_helper import IntegrationHelper
        self._integration_helper = IntegrationHelper(**kwargs) 
        pass
   


    def get_jacobian_helper(self):
        if self._jacobian_helper is None:
            self._init_jacobian_helper(**self._kwargs)
        return self._jacobian_helper
        pass

    def _init_jacobian_helper(self, **kwargs):  
        from ._jacobian_helper import JacobianHelper
        self._jacobian_helper = JacobianHelper(**kwargs) 
        pass


    def get_max_min_helper(self):
        if self._max_min_helper is None:
            self._init_max_min_helper(**self._kwargs)
        return self._max_min_helper
        pass

    def _init_max_min_helper(self, **kwargs):  
        from ._max_min_helper import MaxMaxHelper
        self._max_min_helper = MaxMaxHelper(**kwargs) 
        pass
   
   
    def get_lhopitals_helper(self):
        if self._lhopitals_helper is None:
            self._init_lhopitals_helper(**self._kwargs)
        return self._lhopitals_helper
        pass

    def _init_lhopitals_helper(self, **kwargs):  
        from ._lhopitals_helper import LHopitalsHelper
        self._lhopitals_helper = LHopitalsHelper(**kwargs) 
        pass
   
   
    def get_limit_helper(self):
        if self._limit_helper is None:
            self._init_limit_helper(**self._kwargs)
        return self._limit_helper
        pass

    def _init_limit_helper(self, **kwargs):  
        from ._limit_helper import LimitHelper
        self._limit_helper = LimitHelper(**kwargs) 
        pass

    def get_working_helper(self):
        if self._working_helper is None:
            self._init_working_helper(**self._kwargs)
        return self._working_helper
        pass

    def _init_working_helper(self, **kwargs):  
        from ._working_helper import WorkingHelper
        self._working_helper = WorkingHelper(**kwargs) 
        pass

             
    pass
#class CalculusHelper:
