Python math.erf() Examples

The following are code examples for showing how to use math.erf(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the ones you don't like. You can also save this page to your account.

Example 1
Project: necrobot   Author: incnone   File: statfn.py    (license) View Source Project 7 votes vote down vote up
def get_winrates(user_id_1: int, user_id_2: int, ndchar: NDChar, amplified: bool) -> tuple or None:
    stats_1 = await get_character_stats(user_id_1, ndchar, amplified)
    stats_2 = await get_character_stats(user_id_2, ndchar, amplified)
    if not stats_1.has_wins or not stats_2.has_wins:
        return None

    m2_minus_m1 = stats_2.mean - stats_1.mean
    sum_var = stats_1.var + stats_2.var
    erf_arg = m2_minus_m1 / math.sqrt(2*sum_var)
    if m2_minus_m1 > 0:
        winrate_of_1_if_both_finish = (1.0 + math.erf(erf_arg))/2.0
    else:
        winrate_of_1_if_both_finish = (1.0 - math.erf(-erf_arg))/2.0

    both_finish_prob = stats_1.winrate * stats_2.winrate
    neither_finish_prob = (1-stats_1.winrate)*(1-stats_2.winrate)
    winrate_of_1 = winrate_of_1_if_both_finish*both_finish_prob + (stats_1.winrate - both_finish_prob)
    winrate_of_2 = (1.0-winrate_of_1_if_both_finish)*both_finish_prob + (stats_2.winrate - both_finish_prob)
    return winrate_of_1, winrate_of_2, neither_finish_prob 
Example 2
Project: neva   Author: marcobardoscia   File: ibeval.py    (GNU Lesser General Public License v3.0) View Source Project 6 votes vote down vote up
def blackcox_pd(equity, extasset, sigma):
    """Compute the probability of default for external assets following a 
    Geometric Brownian Motion and the Black and Cox model.

    Parameters:
        equity (float): equity
        extasset (float): external assets
        sigma (float): volatility of the Geometric Browninan Motion
    
    Returns:
        probability of default
    """
    if equity <= 0.0:
        return 1.0
    if equity >= extasset:
        return 0.0
    else:
        #return 1 + (- 1/2 * (1 + math.erf((-math.log(1 - equity/extasset) - sigma**2/2) / 
        #                                  (math.sqrt(2) * sigma)) )
        #            + (extasset/equity)/2 * (1 + math.erf((math.log(1 - equity/extasset) - sigma**2/2) / 
        #                                                  (math.sqrt(2) * sigma)) ) )
        return (1/2 * (1 + math.erf((math.log(1 - equity/extasset) + sigma**2/2) / 
                                    (math.sqrt(2) * sigma)) ) + 
                (extasset/(extasset - equity))/2 * (1 + math.erf((math.log(1 - equity/extasset) - sigma**2/2) / 
                                                                 (math.sqrt(2) * sigma)) ) ) 
Example 3
Project: BlackScholes_bench   Author: IntelPython   File: bs_erf_numba_guvec_par.py    (license) View Source Project 6 votes vote down vote up
def black_scholes_numba_opt(price, strike, t, mr, sig_sig_two, vol, call, put):
        P = float( price [0] )
        S = strike [0]
        T = t [0]
        
        a = log(P / S)
        b = T * mr[0]
        
        z = T * sig_sig_two[0]
        c = 0.25 * z
        y = 1./sqrt(z)
        
        w1 = (a - b + c) * y
        w2 = (a - b - c) * y
        
        d1 = 0.5 + 0.5 * erf(w1)
        d2 = 0.5 + 0.5 * erf(w2)
        
        Se = exp(b) * S

        res = P * d1 - Se * d2
        call [0] = res
        put [0] = res - P + Se 
Example 4
Project: BlackScholes_bench   Author: IntelPython   File: bs_erf_numba_vec.py    (license) View Source Project 6 votes vote down vote up
def black_scholes_numba_opt(price, strike, t, mr, sig_sig_two):
        P = price
        S = strike
        T = t
        
        a = log(P / S)
        b = T * mr
        
        z = T * sig_sig_two
        c = 0.25 * z
        y = 1./sqrt(z)
        
        w1 = (a - b + c) * y
        w2 = (a - b - c) * y
        
        d1 = 0.5 + 0.5 * erf(w1)
        d2 = 0.5 + 0.5 * erf(w2)
        
        Se = exp(b) * S
        
        r  = P * d1 - Se * d2
        return complex(r, r - P + Se) 
Example 5
Project: BlackScholes_bench   Author: IntelPython   File: bs_erf_numba_vec_par.py    (license) View Source Project 6 votes vote down vote up
def black_scholes_numba_opt(price, strike, t, mr, sig_sig_two):
        P = price
        S = strike
        T = t
        
        a = log(P / S)
        b = T * mr
        
        z = T * sig_sig_two
        c = 0.25 * z
        y = 1./sqrt(z)
        
        w1 = (a - b + c) * y
        w2 = (a - b - c) * y
        
        d1 = 0.5 + 0.5 * erf(w1)
        d2 = 0.5 + 0.5 * erf(w2)
        
        Se = exp(b) * S
        
        r  = P * d1 - Se * d2
        return complex(r, r - P + Se) 
Example 6
Project: caly-recommend-system   Author: CalyFactory   File: reco.py    (license) View Source Project 5 votes vote down vote up
def __get_snd_score(self, x):
        return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0 
Example 7
Project: neva   Author: marcobardoscia   File: ibeval.py    (GNU Lesser General Public License v3.0) View Source Project 5 votes vote down vote up
def lognormal_pd(equity, extasset, sigma):
    """Compute the probability of default for external assets following a 
    Geometric Brownian Motion.
    
    Such probability of default is the correct probability of default to use 
    for the NEVA interbank valuation function with external assets following a
    Geometric Brownian Motion, implemented in `exante_en_merton_gbm`. See 
    Eq. (16a) in [1].

    Parameters:
        equity (float): equity
        extasset (float): external assets
        sigma (float): volatility of the Geometric Browninan Motion
    
    Returns:
        probability of default

    References:
        [1] P. Barucca, M. Bardoscia, F. Caccioli, M. D'Errico, G. Visentin, 
            S. Battiston, G. Caldarelli. Network Valuation in Financial Systems, 
            https://arxiv.org/abs/1606.05164
    """
    if equity >= extasset:
        #print('wow1')
        return 0.0
    else:
        #print('wow2', (sigma**2 / 2 + math.log(1.0 - equity/extasset)) / (math.sqrt(2) * sigma))
        #print('wow2', sigma**2 / 2, math.log(1.0 - equity/extasset), (math.sqrt(2) * sigma))
        return 1/2 * (1 + math.erf((sigma**2 / 2 + math.log(1 - equity/extasset))
                                   / (math.sqrt(2) * sigma))) 
Example 8
Project: neva   Author: marcobardoscia   File: ibeval.py    (GNU Lesser General Public License v3.0) View Source Project 5 votes vote down vote up
def lognormal_cav_aext(equity, extasset, ibliabtot, sigma):
    """Compute the conditional expected endogenous recovery for external 
    assets following a Geometric Brownian Motion.
    
    Such conditional expected endogenous recovery is the correct conditional 
    expected endogenous recovery to use for the NEVA interbank valuation 
    function with external assets following a Geometric Brownian Motion, 
    implemented in `end_lognormal_dr`. See Eq. (16b) in [1].

    Parameters:
        equity (float): equity
        extasset (float): external assets
        ibliabtot (float): total interbank liabilities        
        sigma (float): volatility of the Geometric Browninan Motion
    
    Returns:
        conditional expected endogenous recovery

    References:
        [1] P. Barucca, M. Bardoscia, F. Caccioli, M. D'Errico, G. Visentin, 
            S. Battiston, G. Caldarelli. Network Valuation in Financial Systems, 
            https://arxiv.org/abs/1606.05164
    """
    out = 0.0
    if extasset > equity:
        tmp_sigma_1 = sigma**2 / 2
        tmp_sigma_2 = math.sqrt(2) * sigma
        out += 1/2 * (1 + math.erf((math.log(1 - equity/extasset) - tmp_sigma_1) 
                                    / tmp_sigma_2))
        if extasset > equity + ibliabtot:
            out -= 1/2 * (1 + math.erf((math.log(1 - (equity + ibliabtot)/extasset) - 
                                                tmp_sigma_1) 
                                       / tmp_sigma_2))
    return extasset * out 
Example 9
Project: pyflowgo   Author: pyflowgo   File: flowgo_relative_viscosity_model_costa2.py    (license) View Source Project 5 votes vote down vote up
def compute_relative_viscosity(self, state):

        phi = state.get_crystal_fraction()
        if self._strain_rate == 1.0:
            # needle-like B particles from Cimarelli et al., 2011
            # self.phi_max_2 = 0.44
            delta_1 = 4.45
            gama_1 = 8.55
            phi_star_1 = 0.28
            epsilon_1 = 0.001

            f = (1. - epsilon_1) * math.erf(min(25., (
                (math.sqrt(math.pi) / (2. * (1. - epsilon_1))) * (phi / phi_star_1) * (
                    1. + (math.pow((phi / phi_star_1), gama_1))))))

            relative_viscosity = (1. + math.pow((phi / phi_star_1), delta_1)) / (
                math.pow((1. - f), (2.5 * phi_star_1)))
            return relative_viscosity

        if self._strain_rate == 0.0001:
            # needle-like, B particles from Cimarelli et al., 2011
            # self.phi_max = 0.36
            delta_1 = 7.5
            gama_1 = 5.5
            phi_star_1 = 0.26
            epsilon_1 = 0.0002

            f = (1. - epsilon_1) * math.erf(min(25., (
                (math.sqrt(math.pi) / (2. * (1. - epsilon_1))) * (phi / phi_star_1) * (
                    1. + (math.pow((phi / phi_star_1), gama_1))))))

            relative_viscosity = (1. + math.pow((phi / phi_star_1), delta_1)) / (
                math.pow((1. - f), (2.5 * phi_star_1)))
            return relative_viscosity 
Example 10
Project: pyflowgo   Author: pyflowgo   File: flowgo_relative_viscosity_model_costa1.py    (license) View Source Project 5 votes vote down vote up
def compute_relative_viscosity(self, state):

        phi = state.get_crystal_fraction()
        if self._strain_rate == 1.0:
            # for spheres, A particles from Cimarelli et al., 2011
            # self.phi_max = 0.61,
            delta_1 = 11.4
            gama_1 = 1.6
            phi_star_1 = 0.67
            epsilon_1 = 0.01

            f = (1. - epsilon_1) * math.erf(min(25., (
                (math.sqrt(math.pi) / (2. * (1. - epsilon_1))) * (phi / phi_star_1) * (
                    1. + (math.pow((phi / phi_star_1), gama_1))))))

            relative_viscosity = (1. + math.pow((phi / phi_star_1), delta_1)) / (
                math.pow((1. - f), (2.5 * phi_star_1)))
            return relative_viscosity

        if self._strain_rate == 0.0001:
            # spheres A particles from Cimarelli et al., 2011
            # self.phi_max_1 = 0.54,
            delta_1 = 11.48
            gama_1 = 1.52
            phi_star_1 = 0.62
            epsilon_1 = 0.005

            f = (1. - epsilon_1) * math.erf(min(25., (
                (math.sqrt(math.pi) / (2. * (1. - epsilon_1))) * (phi / phi_star_1) * (
                    1. + (math.pow((phi / phi_star_1), gama_1))))))

            relative_viscosity = (1. + math.pow((phi / phi_star_1), delta_1)) / (
                math.pow((1. - f), (2.5 * phi_star_1)))
            return relative_viscosity 
Example 11
Project: python_fun_excercise   Author: pongem   File: probability.py    (license) View Source Project 5 votes vote down vote up
def normal_cdf(x, mu=0,sigma=1):
    return (1 + math.erf((x - mu) / math.sqrt(2) / sigma)) / 2 
Example 12
Project: gym   Author: openai   File: predict_obs_cartpole.py    (license) View Source Project 5 votes vote down vote up
def _step(self, action):
        # the first element of action is the actual current action
        current_action = action[0]

        observation, reward, done, info = self.cartpole._step(current_action)

        if not done:
            # We add the newly predicted observations to the list before checking predictions
            # in order to give the agent a chance to predict the observations that they
            # are going to get _this_ round.
            self.predicted_observations.append(action[1:])

            if self.iteration > TIME_BEFORE_BONUS_ALLOWED:
                for i in xrange(min(NUM_PREDICTED_OBSERVATIONS, len(self.predicted_observations))):
                    l2dist = np.sqrt(np.sum(np.square(np.subtract(
                        self.predicted_observations[-(i + 1)][i],
                        observation
                    ))))

                    bonus = CORRECT_PREDICTION_BONUS * (1 - math.erf(l2dist))

                    reward += bonus

            self.iteration += 1

        return observation, reward, done, info 
Example 13
Project: variantfishtest   Author: ianfab   File: stat_util.py    (license) View Source Project 5 votes vote down vote up
def erf(x):
  #Python 2.7 defines math.erf(), but we need to cater for older versions.
  a = 8*(math.pi-3)/(3*math.pi*(4-math.pi))
  x2 = x*x
  y = -x2 * (4/math.pi + a*x2) / (1 + a*x2)
  return math.copysign(math.sqrt(1 - math.exp(y)), x) 
Example 14
Project: variantfishtest   Author: ianfab   File: stat_util.py    (license) View Source Project 5 votes vote down vote up
def erf_inv(x):
  # Above erf formula inverted analytically
  a = 8*(math.pi-3)/(3*math.pi*(4-math.pi))
  y = math.log(1-x*x)
  z = 2/(math.pi*a) + y/2
  return math.copysign(math.sqrt(math.sqrt(z*z - y/a) - z), x) 
Example 15
Project: variantfishtest   Author: ianfab   File: stat_util.py    (license) View Source Project 5 votes vote down vote up
def phi(q):
  # Cumlative distribution function for the standard Gaussian law: quantile -> probability
  return 0.5*(1+erf(q/math.sqrt(2))) 
Example 16
Project: shakecast   Author: usgs   File: util.py    (license) View Source Project 5 votes vote down vote up
def lognorm_opt(med=0, spread=0, step=.01, just_norm=False, shaking=False):
    p_norm = (math.erf((shaking-med)/(math.sqrt(2) * spread)) + 1)/2
    return p_norm * 100 
Example 17
Project: halite_ranking   Author: Janzert   File: rating_stats.py    (license) View Source Project 5 votes vote down vote up
def phi(x):
    """Cumulative distribution function for the standard normal distribution
    Taken from python math module documentation"""
    return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0 
Example 18
Project: nengo_dl   Author: nengo   File: test_dists.py    (license) View Source Project 5 votes vote down vote up
def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / np.sqrt(2))) 
Example 19
Project: picasso   Author: jungmannlab   File: gaussmle.py    (license) View Source Project 5 votes vote down vote up
def _erf(x):
    ''' Currently not needed, but might be useful for a CUDA implementation '''
    ax = _np.abs(x)
    if ax < 0.5:
        t = x*x
        top = ((((.771058495001320e-04*t-.133733772997339e-02)*t+.323076579225834e-01)*t+.479137145607681e-01)*t+.128379167095513e+00) + 1.0
        bot = ((.301048631703895e-02*t+.538971687740286e-01)*t+.375795757275549e+00)*t + 1.0
        return x * (top / bot)
    if ax < 4.0:
        top = ((((((-1.36864857382717e-07*ax+5.64195517478974e-01)*ax+7.21175825088309e+00)*ax+4.31622272220567e+01)*ax+1.52989285046940e+02)*ax+3.39320816734344e+02)*ax+4.51918953711873e+02)*ax + 3.00459261020162e+02
        bot = ((((((1.0*ax+1.27827273196294e+01)*ax+7.70001529352295e+01)*ax+2.77585444743988e+02)*ax+6.38980264465631e+02)*ax+9.31354094850610e+02)*ax+7.90950925327898e+02)*ax + 3.00459260956983e+02
        erf = 0.5 + (0.5 - _np.exp(-x * x) * top / bot)
        if x < 0.0:
            erf = -erf
        return erf
    if ax < 5.8:
        x2 = x*x
        t = 1.0 / x2
        top = (((2.10144126479064e+00*t+2.62370141675169e+01)*t+2.13688200555087e+01)*t+4.65807828718470e+00)*t + 2.82094791773523e-01
        bot = (((9.41537750555460e+01*t+1.87114811799590e+02)*t+9.90191814623914e+01)*t+1.80124575948747e+01)*t + 1.0
        erf = (.564189583547756e0 - top / (x2 * bot)) / ax
        erf = 0.5 + (0.5 - _np.exp(-x2) * erf)
        if x < 0.0:
            erf = -erf
        return erf
    return _np.sign(x) 
Example 20
Project: picasso   Author: jungmannlab   File: gaussmle.py    (license) View Source Project 5 votes vote down vote up
def _gaussian_integral(x, mu, sigma):
    sq_norm = 0.70710678118654757 / sigma       # sq_norm = sqrt(0.5/sigma**2)
    d = x - mu
    return 0.5 * (_math.erf((d + 0.5) * sq_norm) - _math.erf((d - 0.5) * sq_norm)) 
Example 21
Project: ESPSS   Author: rcalinjageman   File: EPAIRED.py    (license) View Source Project 5 votes vote down vote up
def stdnormdist(x):
  #Cumulative standard normal distribution function
  #Lifted from https://docs.python.org/3.2/library/math.html
  return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0 
Example 22
Project: AI-Fight-the-Landlord   Author: YoungGer   File: predict_obs_cartpole.py    (license) View Source Project 5 votes vote down vote up
def _step(self, action):
        # the first element of action is the actual current action
        current_action = action[0]

        observation, reward, done, info = self.cartpole._step(current_action)

        if not done:
            # We add the newly predicted observations to the list before checking predictions
            # in order to give the agent a chance to predict the observations that they
            # are going to get _this_ round.
            self.predicted_observations.append(action[1:])

            if self.iteration > TIME_BEFORE_BONUS_ALLOWED:
                for i in xrange(min(NUM_PREDICTED_OBSERVATIONS, len(self.predicted_observations))):
                    l2dist = np.sqrt(np.sum(np.square(np.subtract(
                        self.predicted_observations[-(i + 1)][i],
                        observation
                    ))))

                    bonus = CORRECT_PREDICTION_BONUS * (1 - math.erf(l2dist))

                    reward += bonus

            self.iteration += 1

        return observation, reward, done, info 
Example 23
Project: weakmon   Author: rtmrtmrtmrtm   File: wspr.py    (license) View Source Project 5 votes vote down vote up
def normal(x):
    y = 0.5 + 0.5*math.erf(x / 1.414213)
    return y

# how much of the distribution is < x? 
Example 24
Project: weakmon   Author: rtmrtmrtmrtm   File: ft8.py    (license) View Source Project 5 votes vote down vote up
def real_normal(x):
    y = 0.5 + 0.5*math.erf(x / 1.414213)
    return y 
Example 25
Project: Modern-Python-Cookbook   Author: PacktPublishing   File: ch11_r03.py    (license) View Source Project 5 votes vote down vote up
def phi(n):
    """
    Computes the cumulative distribution function of the standard,
    normal distribution for values <= n.

    >>> round(phi(0), 3)
    0.5
    >>> round(phi(-1), 3)
    0.159
    >>> round(phi(+1), 3)
    0.841

    """
    return (1+erf(n/sqrt(2)))/2 
Example 26
Project: Undertone   Author: kgugle   File: undertone.py    (license) View Source Project 5 votes vote down vote up
def percentage_of_area_under_std_normal_curve_from_zcore(z_score):
    return .5 * (math.erf(z_score / 2 ** .5) + 1) 
Example 27
Project: iota   Author: amaneureka   File: thinkstats2.py    (license) View Source Project 5 votes vote down vote up
def StandardNormalCdf(x):
    """Evaluates the CDF of the standard Normal distribution.
    
    See http://en.wikipedia.org/wiki/Normal_distribution
    #Cumulative_distribution_function

    Args:
        x: float
                
    Returns:
        float
    """
    return (math.erf(x / ROOT2) + 1) / 2 
Example 28
Project: necrobot   Author: incnone   File: ratingutil.py    (license) View Source Project 5 votes vote down vote up
def get_winrate(rating_1: Rating, rating_2: Rating):
    delta_mu = rating_1.mu - rating_2.mu
    if delta_mu >= 0:
        beta = trueskill.global_env().beta
        denom = sqrt(2 * (2 * beta * beta + rating_1.sigma * rating_1.sigma + rating_2.sigma * rating_2.sigma))
        return (erf(delta_mu/denom) + 1.0)/2.0
    else:
        return 1.0 - get_winrate(rating_2, rating_1) 
Example 29
Project: ThinkX   Author: AllenDowney   File: thinkstats2.py    (license) View Source Project 5 votes vote down vote up
def StandardNormalCdf(x):
    """Evaluates the CDF of the standard Normal distribution.
    
    See http://en.wikipedia.org/wiki/Normal_distribution
    #Cumulative_distribution_function

    Args:
        x: float
                
    Returns:
        float
    """
    return (math.erf(x / ROOT2) + 1) / 2 
Example 30
Project: ThinkX   Author: AllenDowney   File: thinkbayes2.py    (license) View Source Project 5 votes vote down vote up
def StandardNormalCdf(x):
    """Evaluates the CDF of the standard Normal distribution.
    
    See http://en.wikipedia.org/wiki/Normal_distribution
    #Cumulative_distribution_function

    Args:
        x: float
                
    Returns:
        float
    """
    return (math.erf(x / ROOT2) + 1) / 2 
Example 31
Project: qfrm   Author: pjgranahan   File: Util.py    (license) View Source Project 5 votes vote down vote up
def norm_cdf(x, mu=0, sigma=1):
        """

        Parameters
        ----------
        x :
        mu : float
            distribution's mean
        sigma : float
            distribution's standard deviation

        Returns
        -------
        float
            pdf or cdf value, depending on input flag ``f``

        Notes
        -----
        http://stackoverflow.com/questions/809362/how-to-calculate-cumulative-normal-distribution-in-python

        Examples
        --------
        Compares total absolute error for 100 values

        >>> from scipy.stats import norm
        >>> sum( [abs(Util.norm_cdf(x) - norm.cdf(x)) for x in range(100)])
        3.3306690738754696e-16
        """

        y = 0.5 * (1 - math.erf(-(x - mu)/(sigma * math.sqrt(2.0))))
        if y > 1: y = 1
        return y 
Example 32
Project: Data-Science   Author: titu1994   File: Probability.py    (license) View Source Project 5 votes vote down vote up
def normalCDF(x, mu = 0, sigma = 1.0):
    return (1 + math.erf((x - mu) / math.sqrt(2) / sigma)) / 2 
Example 33
Project: gym-adv   Author: lerrel   File: predict_obs_cartpole.py    (license) View Source Project 5 votes vote down vote up
def _step(self, action):
        # the first element of action is the actual current action
        current_action = action[0]

        observation, reward, done, info = self.cartpole._step(current_action)

        if not done:
            # We add the newly predicted observations to the list before checking predictions
            # in order to give the agent a chance to predict the observations that they
            # are going to get _this_ round.
            self.predicted_observations.append(action[1:])

            if self.iteration > TIME_BEFORE_BONUS_ALLOWED:
                for i in xrange(min(NUM_PREDICTED_OBSERVATIONS, len(self.predicted_observations))):
                    l2dist = np.sqrt(np.sum(np.square(np.subtract(
                        self.predicted_observations[-(i + 1)][i],
                        observation
                    ))))

                    bonus = CORRECT_PREDICTION_BONUS * (1 - math.erf(l2dist))

                    reward += bonus

            self.iteration += 1

        return observation, reward, done, info 
Example 34
Project: BlackScholes_bench   Author: IntelPython   File: bs_erf_naive.py    (license) View Source Project 5 votes vote down vote up
def black_scholes ( nopt, price, strike, t, rate, vol, call, put ):
    mr = -rate
    sig_sig_two = vol * vol * 2
    
    for i in range(nopt):
        P = float( price [i] )
        S = strike [i]
        T = t [i]
        
        a = log(P / S)
        b = T * mr
        
        z = T * sig_sig_two
        c = 0.25 * z
        y = invsqrt(z)
        
        w1 = (a - b + c) * y
        w2 = (a - b - c) * y
        
        d1 = 0.5 + 0.5 * erf(w1)
        d2 = 0.5 + 0.5 * erf(w2)
        
        Se = exp(b) * S
        
        call [i] = P * d1 - Se * d2
        put [i] = call [i] - P + Se 
Example 35
Project: BlackScholes_bench   Author: IntelPython   File: bs_erf_numba_jit.py    (license) View Source Project 5 votes vote down vote up
def black_scholes( nopt, price, strike, t, rate, vol, call, put):
    mr = -rate
    sig_sig_two = vol * vol * 2

    for i in range(nopt):
        P = float( price[i] )
        S = strike [i]
        T = t [i]

        a = log(P / S)
        b = T * mr

        z = T * sig_sig_two
        c = 0.25 * z
        y = 1./sqrt(z)

        w1 = (a - b + c) * y 
        w2 = (a - b - c) * y

        d1 = 0.5 + 0.5 * erf(w1)
        d2 = 0.5 + 0.5 * erf(w2)

        Se = exp(b) * S

        call [i] = P * d1 - Se * d2
        put [i] = call [i] - P + Se 
Example 36
Project: HackerRank_Python   Author: csixteen   File: day5_normal1.py    (license) View Source Project 5 votes vote down vote up
def F(x, u, std_dev):
    return (1.0 + erf((x-u) / (std_dev * sqrt(2.0)))) / 2.0 
Example 37
Project: HackerRank_Python   Author: csixteen   File: day5_normal2.py    (license) View Source Project 5 votes vote down vote up
def F(x, u, std_dev):
    return (1.0 + erf((x-u) / (std_dev * sqrt(2.0)))) / 2.0 
Example 38
Project: HackerRank_Python   Author: csixteen   File: day6_central_limit_theorem3.py    (license) View Source Project 5 votes vote down vote up
def F(x, u, std_dev):
    return 0.5*(1 + erf((x-u)/(std_dev*(2**0.5)))) 
Example 39
Project: F_UNCLE   Author: fraserphysics   File: Ptw.py    (license) View Source Project 4 votes vote down vote up
def __call__(self, temp, strain_rate, material, **overrides):
        """Solves for the yield stress and flow stress at the given condition

        Args:
           temp(float): Temperature, in degrees Kelvin
       strain_rate(float): Strain rate, in sec**-1
       material(str): Key for material type
        Keyword Args:
           **overrides(dict): Passed as a chain of keyword arguments. These
                              arguments override any material property

        Return:
           flow_stress(float): Flow stress in ??Pa??
           yield_stress(float): Yield stress in ??Pa??

        """

        g_modu, t_norm, psi_norm = self.__pre__(temp, strain_rate, material,
                                                **overrides)

        s_o = self.get_option('s_o')
        s_inf = self.get_option('s_inf')
        kappa = self.get_option('kappa')
        beta = self.get_option('beta')
        y_o = self.get_option('y_o')
        y_inf = self.get_option('y_inf')
        y_1 = self.get_option('y_1')
        y_2 = self.get_option('y_2')

        if psi_norm == 0.0:
            erf_psi_norm = 0.0
        else:
            erf_psi_norm = erf(kappa * t_norm * log(psi_norm**(-1)))
        # end

        glide_flow_stress = s_o - (s_o - s_inf) * erf_psi_norm

        shock_flow_stress = s_o * psi_norm**beta
        glide_yield_stress = y_o - (y_o - y_inf) * erf_psi_norm

        shock_yield_stress = y_1 * psi_norm**y_2

        flow_stress = max((glide_flow_stress, shock_flow_stress))
        yield_stress = max((glide_yield_stress,
                            min((shock_yield_stress, shock_flow_stress))))

        flow_stress *= g_modu
        yield_stress *= g_modu

        return flow_stress, yield_stress