from marketsim import registry
from marketsim.gen._out._ifunction import IFunctionfloat
@registry.expose(["Random", "normalvariate"])
class normalvariate_FloatFloat(IFunctionfloat):
    """ 
    """ 
    def __init__(self, Mu = None, Sigma = None):
        from marketsim import rtti
        self.Mu = Mu if Mu is not None else 0.0
        self.Sigma = Sigma if Sigma is not None else 1.0
        rtti.check_fields(self)
    
    @property
    def label(self):
        return repr(self)
    
    _properties = {
        'Mu' : float,
        'Sigma' : float
    }
    def __repr__(self):
        return "normalvariate(%(Mu)s, %(Sigma)s)" % self.__dict__
    
    def __call__(self, *args, **kwargs):
        import random
        return random.normalvariate(self.Mu, self.Sigma)
    
    def _casts_to(self, dst):
        return normalvariate_FloatFloat._types[0]._casts_to(dst)
    
def normalvariate(Mu = None,Sigma = None): 
    from marketsim import rtti
    if Mu is None or rtti.can_be_casted(Mu, float):
        if Sigma is None or rtti.can_be_casted(Sigma, float):
            return normalvariate_FloatFloat(Mu,Sigma)
    raise Exception('Cannot find suitable overload for normalvariate('+str(Mu) +':'+ str(type(Mu))+','+str(Sigma) +':'+ str(type(Sigma))+')')

15bd324ac772f545e5d89081419ad1c349b685aa
<mask token>


@registry.expose(['Random', 'normalvariate'])
class normalvariate_FloatFloat(IFunctionfloat):
    <mask token>
    <mask token>

    @property
    def label(self):
        return repr(self)
    <mask token>

    def __repr__(self):
        return 'normalvariate(%(Mu)s, %(Sigma)s)' % self.__dict__

    def __call__(self, *args, **kwargs):
        import random
        return random.normalvariate(self.Mu, self.Sigma)

    def _casts_to(self, dst):
        return normalvariate_FloatFloat._types[0]._casts_to(dst)


<mask token>

<mask token>


@registry.expose(['Random', 'normalvariate'])
class normalvariate_FloatFloat(IFunctionfloat):
    <mask token>

    def __init__(self, Mu=None, Sigma=None):
        from marketsim import rtti
        self.Mu = Mu if Mu is not None else 0.0
        self.Sigma = Sigma if Sigma is not None else 1.0
        rtti.check_fields(self)

    @property
    def label(self):
        return repr(self)
    <mask token>

    def __repr__(self):
        return 'normalvariate(%(Mu)s, %(Sigma)s)' % self.__dict__

    def __call__(self, *args, **kwargs):
        import random
        return random.normalvariate(self.Mu, self.Sigma)

    def _casts_to(self, dst):
        return normalvariate_FloatFloat._types[0]._casts_to(dst)


<mask token>

<mask token>


@registry.expose(['Random', 'normalvariate'])
class normalvariate_FloatFloat(IFunctionfloat):
    <mask token>

    def __init__(self, Mu=None, Sigma=None):
        from marketsim import rtti
        self.Mu = Mu if Mu is not None else 0.0
        self.Sigma = Sigma if Sigma is not None else 1.0
        rtti.check_fields(self)

    @property
    def label(self):
        return repr(self)
    _properties = {'Mu': float, 'Sigma': float}

    def __repr__(self):
        return 'normalvariate(%(Mu)s, %(Sigma)s)' % self.__dict__

    def __call__(self, *args, **kwargs):
        import random
        return random.normalvariate(self.Mu, self.Sigma)

    def _casts_to(self, dst):
        return normalvariate_FloatFloat._types[0]._casts_to(dst)


<mask token>

from marketsim import registry
from marketsim.gen._out._ifunction import IFunctionfloat


@registry.expose(['Random', 'normalvariate'])
class normalvariate_FloatFloat(IFunctionfloat):
    """ 
    """

    def __init__(self, Mu=None, Sigma=None):
        from marketsim import rtti
        self.Mu = Mu if Mu is not None else 0.0
        self.Sigma = Sigma if Sigma is not None else 1.0
        rtti.check_fields(self)

    @property
    def label(self):
        return repr(self)
    _properties = {'Mu': float, 'Sigma': float}

    def __repr__(self):
        return 'normalvariate(%(Mu)s, %(Sigma)s)' % self.__dict__

    def __call__(self, *args, **kwargs):
        import random
        return random.normalvariate(self.Mu, self.Sigma)

    def _casts_to(self, dst):
        return normalvariate_FloatFloat._types[0]._casts_to(dst)


def normalvariate(Mu=None, Sigma=None):
    from marketsim import rtti
    if Mu is None or rtti.can_be_casted(Mu, float):
        if Sigma is None or rtti.can_be_casted(Sigma, float):
            return normalvariate_FloatFloat(Mu, Sigma)
    raise Exception('Cannot find suitable overload for normalvariate(' +
        str(Mu) + ':' + str(type(Mu)) + ',' + str(Sigma) + ':' + str(type(
        Sigma)) + ')')

from marketsim import registry
from marketsim.gen._out._ifunction import IFunctionfloat
@registry.expose(["Random", "normalvariate"])
class normalvariate_FloatFloat(IFunctionfloat):
    """ 
    """ 
    def __init__(self, Mu = None, Sigma = None):
        from marketsim import rtti
        self.Mu = Mu if Mu is not None else 0.0
        self.Sigma = Sigma if Sigma is not None else 1.0
        rtti.check_fields(self)
    
    @property
    def label(self):
        return repr(self)
    
    _properties = {
        'Mu' : float,
        'Sigma' : float
    }
    def __repr__(self):
        return "normalvariate(%(Mu)s, %(Sigma)s)" % self.__dict__
    
    def __call__(self, *args, **kwargs):
        import random
        return random.normalvariate(self.Mu, self.Sigma)
    
    def _casts_to(self, dst):
        return normalvariate_FloatFloat._types[0]._casts_to(dst)
    
def normalvariate(Mu = None,Sigma = None): 
    from marketsim import rtti
    if Mu is None or rtti.can_be_casted(Mu, float):
        if Sigma is None or rtti.can_be_casted(Sigma, float):
            return normalvariate_FloatFloat(Mu,Sigma)
    raise Exception('Cannot find suitable overload for normalvariate('+str(Mu) +':'+ str(type(Mu))+','+str(Sigma) +':'+ str(type(Sigma))+')')
