Beispiel #1
0
def wangdomain(own_ship_xy, length, vown, cog=0, k_shape=2, r_static=0.5):
    """
    Parameters
    ----------
    own_ship_xy : (float, float)
        xy coordinates of ellipse centre.
    cog : scalar, optional
        Rotation in degrees anti-clockwise.
    vown:  is the own ship speed represented in knots
    k_shape :shape index
    """
    # Constant
    r0 = 0.5
    # L is the own ship length,
    # k_AD and k_DT represent gains of the advance, AD ,
    # and the tactical diameter, D T ,
    k_ad = 10**(0.359 * lg(vown) + 0.0952)
    k_dt = 10**(0.541 * lg(vown) - 0.0795)
    R_fore = (1 + 1.34 * sqrt((k_ad)**2 + (k_dt / 2)**2)) * length
    R_aft = (1 + 0.67 * sqrt((k_ad)**2 + (k_dt / 2)**2)) * length
    R_starb = (0.2 + k_dt) * length
    R_port = (0.2 + 0.75 * k_dt) * length

    R = np.array((R_fore, R_aft, R_starb, R_port))
    r_fuzzy = ((ln(1 / r_static)) / (ln(1 / r0)))**(1 / k_shape)
    R_fuzzy = r_fuzzy * R
    # y_1: first quadrant  x >= 0 y >= 0
    x_max = R_fuzzy[0]
    x_min = -R_fuzzy[1]
    x_serises_plus = np.linspace(0, x_max, 80)
    x_serises_minus = np.linspace(x_min, -0.01, 80)
    # x>=0, y>=0
    y_1 = R_fuzzy[2] * pow(
        (1 - (x_serises_plus / R_fuzzy[0])**k_shape), 1 / k_shape)
    y_4 = R_fuzzy[3] * -pow(
        (1 - (x_serises_plus / R_fuzzy[0])**k_shape), 1 / k_shape)
    y_2 = R_fuzzy[2] * pow(
        (1 - (-x_serises_minus / R_fuzzy[1])**k_shape), 1 / k_shape)
    y_3 = R_fuzzy[3] * -pow(
        (1 - (-x_serises_minus / R_fuzzy[1])**k_shape), 1 / k_shape)
    # stack the column
    curve1 = np.column_stack((x_serises_plus, y_1))
    curve2 = np.column_stack((x_serises_minus, y_2))
    curve3 = np.column_stack((x_serises_minus, y_3))
    curve4 = np.column_stack((x_serises_plus, y_4))
    # Primacy connection
    curve4 = np.flipud(curve4)
    curve3 = np.flipud(curve3)
    # cat the data series to one curve.
    curves = np.row_stack((curve1, curve4, curve3, curve2)).T
    curves[0, :] += own_ship_xy[0]
    curves[1, :] += own_ship_xy[1]
    #
    t_rot = pi * cog / 180 - pi / 2
    R_rot = np.array([[cos(t_rot), sin(t_rot)], [-sin(t_rot), cos(t_rot)]])
    for i in range(curves.shape[1]):
        curves[:, i] = np.dot(R_rot, curves[:, i])
    return curves
def print_rates(E):
  from math import log as lg
  print   '%.4e   -    %.4e   -    ' \
    %(E[0][0], E[0][1])
  for i in range(1, len(E)):
    r1 = lg(E[i-1][0]/E[i][0], 2)
    r2 = lg(E[i-1][1]/E[i][1], 2)
    print '%.4e  %.2f  %.4e  %.2f' \
      %(E[i][0], r1, E[i][1], r2)
  print '\n'
def get_L(data, num_clusters, mean_li, cov_li, phi_matrix, pi_vect):
  L_func_value= 0
  #print(pi_vect)

  #print(phi_matrix)

  for i in range(len(data)):
    for j in range(num_clusters):
      L_func_value += phi_matrix[i][j] *  ( lg(pi_vect[j]) + lg(ss.multivariate_normal.pdf(data[i], mean_li[j], cov_li[j], allow_singular=True) ) ) 

  print(L_func_value)
  return L_func_value
Beispiel #4
0
def expg( a, b ):
    """
    Returns the largest ( base, exponent ) tuple from a, b.
    This solution utilizes logarithmic properties to simplify the calculations.

    Consider two base-exponent pairs that we want to compare, say a**b and c**d:
        a**b > c**d
        ( 10**loga )**b > ( 10**logc )**d
        10**( loga * b ) > 10**( logc * d )

    Now we have the same base, and we can simplify our comparison:
        loga * b > logc * d

    """
    return a if lg( a[ 0 ] ) * a[ 1 ] > lg( b[ 0 ] ) * b[ 1 ] else b
Beispiel #5
0
def get_public_tags_cloud(force_reload=False):
    """
    return tags cloud: list of tuples-pairs ("tag", "tag_weight"), tag_weight - is a number divisible by 5,
    0 <= tag_weight <= 100
    Only for published articles.
    """
    value = cache.get_value('tags_cloud')
    if value is None or force_reload:
        dbsession = DBSession()
        q = dbsession.query(func.count(Tag.id), Tag.tag).join(Article).filter(Article.is_draft==False).group_by(Tag.tag)
        items = list()
        counts = list()
        total = 0
        for rec in q.all():
            if rec[0] <= 0:
                continue
            total += rec[0]
            items.append((rec[1], int(rec[0])))
            counts.append(int(rec[0]))

        if len(counts) != 0:
            min_count = min(counts)
            max_counts = max(counts)

            if min_count == max_counts:
                # i.e. all tags counts are the same, so they have the same weight
                weights = [(x[0], 50) for x in items]
            else:
                lmm = lg(max_counts) - lg(min_count)

                weights = [(x[0], (lg(x[1])-lg(min_count)) / lmm) for x in items]
                weights = [(x[0], int(5*(int(100*x[1])/5))) for x in weights]

            value = weights
        else:
            value = []

        cache.set_value('tags_cloud', value)

    return value
Beispiel #6
0
def pearson_criterion(sample, distribution, mean, var):
    a = 0.05
    n = len(sample)
    # k = int(1.72 * n ** (1 / 3))
    k = int(1 + 3.3 * lg(n))
    xsi = get_xsi(k - 1, 1 - a)
    ns, deltas = divide_sample(sample, k, mean, 0.3)
    print(f"ni: {str(ns)}")
    ps = count_pi(deltas, distribution)
    print(f"pi: {str(ps)}")
    xsi_b = count_xsi_b(ns, ps, n)
    if xsi_b < xsi:
        return True
    return False
Beispiel #7
0
class Func:
    n,p,s,v = map(float,input().split())
    sq2 = sqrt(2)
    lgn = lg(n)
    a = (n/(p*10**9))
    b = s/v

    @staticmethod
    def f(c):
        return Func.a * (Func.lgn)**(c*Func.sq2) + Func.b * (1+1/c)

    @staticmethod
    def g(c):
        return 1/(Func.a * (Func.lgn)**(c*Func.sq2) + Func.b * (1+1/c))
Beispiel #8
0
def pre_process():
    years_to_bits = {
        y: 2**(i + 2)
        for i, y in enumerate(range(1960, 2170, 10))
    }
    years_to_n = {}
    s, n, year = 0, 2, 1960
    while year < 2170:
        s += lg(n)
        if s > years_to_bits[year]:
            years_to_n[year] = n - 1
            year += 10
        n += 1
    return years_to_n
Beispiel #9
0
 def check_n_selfnum(num):
     temp=[num]
     k=9
     while(k>1):
         k =int(lg(num+0.1))
         t   =int(num//pow(10, k ))
         num =int(num%pow(10, k))
         temp.append(t)
         # print('k:', k ,' num: ',num)
     temp.append(num%10)
     # print('temp : ', temp, 'remove : ',sum(temp))
     try:
         self_num_list.remove(sum(temp))
     except:
         pass
def getAuxInfo(logFileName, profileFileName):
    logFile = open(logFileName, 'r')
    csv_reader = csv.reader(logFile, delimiter='\t')
    log = [tuple(x) for x in csv_reader]
    log = log[1:]
    logFile.close()
    # MSn_Scan -- 0
    # Parent_Scan -- 2
    # Mono_Intensity -- 10
    if log[7] == ('MSn_Scan', 'MSn_Level', 'Parent_Scan', 'Parent_Scan_Level',
                  'Parent_Mz', 'Mono_Mz', 'Charge_State', 'Monoisotopic_Mass',
                  'Isotopic_Fit', 'Parent_Intensity', 'Mono_Intensity'):
        log = log[8:]
    else:
        raise Exception

    profileFile = open(profileFileName, 'r')
    csv_reader = csv.reader(profileFile, delimiter='\t')
    profile = [tuple(x) for x in csv_reader]
    profileFile.close()
    # AGC_accumulation_time -- 2
    # TIC -- 3
    if profile[0] == ('MSn_Scan', 'Parent_Scan', 'AGC_accumulation_time',
                      'TIC'):
        profile = profile[1:]
    else:
        raise Exception

    dictAuxInfo = {}
    # len(log) should be equal to len(profile) now
    for i in range(len(log)):
        dictAuxInfo[log[i][0]] = (log[i][2],
                                  lg(
                                      float(log[i][10]) *
                                      float(profile[i][2]) / 1000,
                                      10), float(profile[i][3]) *
                                  float(profile[i][2]) / 1000)
    # returns key:ms2 values:(ms1, log10IntensityInTheTrap, TIC_InTheTrap)
    return dictAuxInfo
Beispiel #11
0
    def decrypt(self, e):
        """e is an encrypted message encoded as a polynomial"""
        if self._f is None or self._g is None:
            raise Exception("Private key not found.")

        if e._N <= self._P.get_N():

            if not self._fp:
                self._fp = invert_in_p(self._f, self._P.get_N())
            if not self._fq:
                self._fq = invert_in2tor(self._f, self._P.get_N(),
                                         int(lg(self._P.get_q())))

            assert (self._h == self._fq * self._g)

            a = (self._f * e) % self._P.get_q()
            b = (self._fp * a) % self._P.get_p()

            return b  # decrypted message
        else:
            raise Exception("e is too large, must be equal or under size %d" %
                            self._P.get_N())
Beispiel #12
0
def rel(val: float, peak: float, digs: int = 0) -> str:
    if val == 0:
        return '-inf'
    return str(round(20 * lg(abs(val) / peak), digs))
Beispiel #13
0
#! /usr/bin/env python
from functools import partial
import sys

if sys.version_info > (3, 5):
    # python 3.5 or above
    from math import log2
    log = log2
    str_utf8 = lambda x: str(x, 'utf-8')
else:
    from math import log as lg
    log = lambda x: lg(x, 2) if x > 0 else 0

    str_utf8 = lambda x: str(x).encode('utf-8')

import click

attrs = [
    "edibility",
    "cap-shape",
    "cap-surface",
    "cap-color",
    "bruises?",
    "odor",
    "grill-attachment",
    "grill-spacing",
    "grill-size",
    "grill-color",
    "stalk-shape",
    "stalk-root",
    "stalk-surface-above-ring",
def sharing_chromosomes(n, k):
    return lg(sum(c(n, i) for i in range(k, n + 1))) - (n * lg(2))
Beispiel #15
0
def l2(num):
    """
    log base 2
    :rtype real
    """
    return lg(num, 2)
Beispiel #16
0
from math import log as lg

if __name__=='__main__':
    n,b,p=map(int,input().split())
    bottle= 0
    k = pow(2,int(lg(n,2)))
    towel = n*p
    while k>=2:  
        bottle += (k*b+int(k/2))
        n = int(k/2)+n-k     #winners + rem
        if n>0:
            k = pow(2,int(lg(n,2)))
            
    print (bottle,towel)
    #else
    #print ((n-1)*(2*b+1),n*p)

'''
A. Tennis Tournament
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

A tennis tournament with n participants is running. The participants are playing by an olympic system, so the winners move on and the losers drop out.

The tournament takes place in the following way (below, m is the number of the participants of the current round):
Beispiel #17
0
#difficulty calculator
from math import log as lg

rate = 100 #hash/sec
idealreward = 1.0/60.0 #block/sec
"""
idealreward = 1-(1-difficulty)**rate
lg(id - 1)/lg(rate) = 1 - difficulty
1- lg(id - 1)/lg(rate) = difficulty
"""
difficulty = lg(1-idealreward**rate,.5)

print difficulty
print (2**(160-difficulty))/(2**160)
Beispiel #18
0
    157185040413215530975165633061, 178617532837899776787217832941,
    96368378329569366965481375161, 41702562059995270288416739123,
    234425024443044792063543979349, 147325628837781527224761907889,
    89981271475268439210802711349, 216948066429127138241721468529,
    118962322543851674548159048321
]

#for p in TIMEOUTS:
#    print(p)

from math import log2 as lg
import random

semiprimes = set([p * q for p in FIFTEEN_DIGIT for q in FIFTEEN_DIGIT])
#semiprimes = set([p*q for p in TEN_DIGIT for q in TWENTY_DIGIT])

suitable = [n for n in semiprimes if 96 <= lg(n) < 97]
#suitable = [n for n in semiprimes if lg(n) < 97]

#print (format(max(suitable), "02x"))
#print (format(min(suitable), "02x"))
#print (len(suitable))

random.shuffle(suitable)

#for n in suitable:
for n in suitable[:200]:
    #for n in sorted(suitable)[-10:]:
    #pass
    print("0x{:02x}".format(n))
Beispiel #19
0
147325628837781527224761907889,
89981271475268439210802711349,
216948066429127138241721468529,
118962322543851674548159048321
]

#for p in TIMEOUTS:
#    print(p)

from math import log2 as lg
import random

semiprimes = set([p*q for p in FIFTEEN_DIGIT for q in FIFTEEN_DIGIT])
#semiprimes = set([p*q for p in TEN_DIGIT for q in TWENTY_DIGIT])

suitable = [n for n in semiprimes if 96 <= lg(n) < 97]
#suitable = [n for n in semiprimes if lg(n) < 97]


#print (format(max(suitable), "02x"))
#print (format(min(suitable), "02x"))
#print (len(suitable))

random.shuffle(suitable)

#for n in suitable:
for n in suitable[:200]:
#for n in sorted(suitable)[-10:]:
    #pass
    print("0x{:02x}".format(n))
Beispiel #20
0
s = s1 = s2 = a1 = a2 = x = f = eps = i  = 0

while not ((0 < eps < 1) and (-1 < x < 1)):
    eps = float(input("Введите точность eps, (0 ;1) << "))
    x   = float(input("Введите значение x,   (-1;1) << "))

s1 = s2 = a1 = a2 = x
i  = 2

while (abs(a1 + a2) >= eps) and (i < 300):
    a1 *= ((-x) * (i-1) / i)
    a2 *= ((-x) / i)

    s1 += a1
    s2 += a2
    i  += 1

s = s1 + s2
f = ln(x) - exp(-x) + 1

eOut = trunc(lg(round(1/eps))) + 1

print(\
    "\n"*2,\
    f"Сумма ряда S          >> %1.{eOut}f"%s, "\n",\
    f"Контрольная формула F >> %1.{eOut}f"%f, "\n",\
    "Количество итераций i >> ", i, "\n",\
    f"S - F                 >> %1.{eOut}f"%(s-f),\
sep="")
Beispiel #21
0
def log0(x):
    return 0 if x == 0 else lg(x)
Beispiel #22
0
def main():
    n, k = map(int, input().split())
    if k >= lg(n):
        print('Your wish is granted!')
    else:
        print('You will become a flying monkey!')
Beispiel #23
0
def walther(temp_1, nu_1, temp_2, nu_2, temp_3):
    """

    Calculate the kinematic viscosity at temperature `temp_3` based on the
    kinematic viscosities at temperatures `temp_1` and `temp_2`. The
    implementation follows standard ASTM D341.

    Parameters
    ----------
    temp_1: scalar
        The temperature in :math:`^{\\circ}\\text{C}` that corresponds to the
        kinematic viscosity :code:`nu_1`.
    nu_1: scalar
        The kinematic viscosity in cSt at temperature :code:`temp_1`.
    temp_2: scalar
        The temperature in :math:`^{\\circ}\\text{C}` that corresponds to the
        kinematic viscosity :code:`nu_2`.
    nu_2: scalar
        The kinematic viscosity in cSt at temperature :code:`temp_2`.
    temp_3: ndarray
        The temperature in :math:`^{\\circ}\\text{C}` for which to calculate
        the kinematic viscosity.

    Returns
    -------
    nu_3: ndarray
        The kinematic viscosity in cSt at temperature :code:`temp_3`.

    """
    abs_zero = -273.15
    viscs = [nu_1, nu_2]
    thetas = [temp_1 - abs_zero, temp_2 - abs_zero, temp_3 - abs_zero]

    zed = [__zedwalther(nu) for nu in viscs]
    const_a = (lg(lg(zed[0])) - lg(lg(zed[1])) *
               lg(thetas[0]) / lg(thetas[1])) / \
              (1 - lg(thetas[0]) / lg(thetas[1]))
    const_b = (const_a - lg(lg(zed[1]))) / lg(thetas[1])
    nu_3 = __nuwalther(10**10**(const_a - const_b * np.log10(thetas[2])))
    return nu_3
Beispiel #24
0
def h(distribution):
    return sum(p * lg(1 / p) for p in distribution)
Beispiel #25
0
#difficulty calculator
from math import log as lg

rate = 100  #hash/sec
idealreward = 1.0 / 60.0  #block/sec
"""
idealreward = 1-(1-difficulty)**rate
lg(id - 1)/lg(rate) = 1 - difficulty
1- lg(id - 1)/lg(rate) = difficulty
"""
difficulty = lg(1 - idealreward**rate, .5)

print difficulty
print(2**(160 - difficulty)) / (2**160)