Exemple #1
0
def getInfo(data, target, theta):
    afterSigmoid = sigmoid(data.dot(theta))

    firstList = [ ]
    for k in afterSigmoid:
        m = []
        for x in k:
            m.append(bigfloat.log(x,bigfloat.precision(precision)))
        firstList.append(m)

    secondList = [ ]
    for k in afterSigmoid:
        m = []
        for x in k:
            m.append(bigfloat.log( bigfloat.sub(1. , x) , bigfloat.precision(precision)))
        secondList.append(m)
    
    Ein = 0.
    m = []
    for x,y in zip(firstList, secondList):
        for a,b,t in zip(x,y,target):
            value = bigfloat.add( bigfloat.mul(t[0],a, bigfloat.precision(precision)) , bigfloat.mul( bigfloat.sub(1. ,t[0], bigfloat.precision(precision)) ,a, bigfloat.precision(precision)))
            m.append(value)
    for item in m:
        Ein = bigfloat.add(item, Ein, bigfloat.precision(precision))
    
    Ein = - Ein
    print(Ein)
    gradient = -data.T.dot(target-afterSigmoid)
    return (Ein, gradient)
def Evaluate(pk,cl,ck,s={}):
    #S is for debugging
    (pk0,x,y)=pk
    cl0=[]
    for (i,j) in cl:
        cl0.append(i)
    c0 = SomeWhatEvaluate((pk0,x), cl0, ck)
    z=[None]*(Params.bigo+1)
    for i in range(1,Params.bigo+1):
        k=bigfloat.mul(c0,y[i],bigfloat.precision((Params.kappa+Params.gamma)))
        z[i]=float(bigfloat.mod(k,2,bigfloat.precision((Params.prec))))
    if debug:
        su=0
        yo=0
        for i in range(1,Params.bigo+1):
            if s[i]==1:
                yo=bigfloat.add(yo,y[i],bigfloat.precision((Params.kappa+Params.gamma)))
                su=bigfloat.add(su,z[i],bigfloat.precision(Params.kappa+Params.gamma))
        print "Enc_sum%2=",bigfloat.mod(su,8,bigfloat.precision((Params.prec+Params.gamma)))
        q=bigfloat.div(c0,globsk,bigfloat.precision(Params.kappa+Params.gamma))
        print "(c0/sk)=",q
        q=bigfloat.mul(c0,yo,bigfloat.precision((Params.kappa+Params.gamma)))
        print "(c0*yo)=",q
        q=bigfloat.div(1,globsk,bigfloat.precision(Params.kappa+Params.gamma))
        print "(1/sk)=",q
        print "(yo)=",yo
        print "(c0*1/sk)=",bigfloat.mul(q,c0,bigfloat.precision((Params.prec+Params.gamma)))
        q=bigfloat.div(c0,globsk,bigfloat.precision((Params.prec+Params.gamma)))
        print "(c0/sk)=",q
    c = (c0,z)
    return c
 def _compute_grad(self, children: List) -> bf.BigFloat:
     context = bf.precision(self.grad_precision) + bf.RoundAwayFromZero
     grad = 0
     for (w1, w2), var in children:
         lower, upper = var.grad()
         grad_term = bf.add(bf.mul(w1, lower, context), bf.mul(w2, upper, context), context)
         grad = bf.add(grad_term, grad, context)
     return grad
def partial_right_two_exact(matrix, v1, v2, i1, i2):
    with bf.Context(precision=EXACT_PRECISION):
        n = matrix.shape[0]
        mul1 = matrix[:, i1]
        mul2 = matrix[:, i2]
        low_bound = 2
        for j in xrange(low_bound, n, 1):
            v1_j = bf.BigFloat(v1[j - low_bound])
            v2_j = bf.BigFloat(v2[j - low_bound])
            for i in xrange(n):
                matrix[i, j] = bf.add(matrix[i, j], bf.add(bf.mul(v1_j, mul1[i]), bf.mul(v2_j, mul2[i])))
def predict_dpi(x, s):

    num = 0
    den = 0
    for i in range(len(s)):
        y_i = s[i, len(x)]
        x_i = s[i, :len(x)]
        ex = bg.exp(-0.25 * (math.pow(euclidean_distance(x, x_i), 2)))
        num = bg.add(num, bg.mul(y_i, ex))
        den = bg.add(den, ex)
    return bg.div(num, den)
def tridiagonal_dot_exact(tridiagonal, v, dtype=f64):
    with bf.Context(precision=EXACT_PRECISION):
        n = len(v)
        result = np.zeros(n, dtype=dtype)
        vlist = []
        for i in xrange(n):
            vlist.append(bf.BigFloat(np.float64(v[i])))
        result[0] = bf.add(bf.mul(np.float64(tridiagonal[1, 0]), vlist[0]), bf.mul(np.float64(tridiagonal[0, 1]), vlist[1]))
        for i in xrange(1, n - 1, 1):
            result[i] = bf.add(bf.add(bf.mul(np.float64(tridiagonal[2, i - 1]), vlist[i - 1]), bf.mul(np.float64(tridiagonal[1, i]), vlist[i])), bf.mul(np.float64(tridiagonal[0, i + 1]), vlist[i + 1]))
        result[n - 1] = bf.add(bf.mul(np.float64(tridiagonal[2, n - 2]), vlist[n - 2]), bf.mul(np.float64(tridiagonal[1, n - 1]), vlist[n - 1]))
        return result
def predict_dps(prices, v_bid, v_ask, s1, s2, s3, w):

    dps = []
    w0, w1, w2, w3, w4 = w
    for i in range(120, len(prices) - 1):
        dp1 = predict_dpi(prices[i - 30:i], s1)
        dp2 = predict_dpi(prices[i - 60:i], s2)
        dp3 = predict_dpi(prices[i - 120:i], s3)
        r = (v_bid[i] - v_ask[i]) / (v_bid[i] + v_ask[i])
        dp = bg.add(
            w0,
            bg.add(
                bg.mul(w1, dp1),
                bg.add(bg.mul(w2, dp2), bg.add(bg.mul(w3, dp3), bg.mul(w4,
                                                                       r)))))
        dps.append(float(dp))
    return dps
Exemple #8
0
def sigmoid(s):
    y = []
    for k in s:
        z=[]
        for l in k:
            z.append( bigfloat.div( 1. , bigfloat.add(1,bigfloat.exp(-l,bigfloat.precision(precision)))))
        y.append(z)
    return np.array(y)
def partial_right_one_exact(matrix, vector, index):
    with bf.Context(precision=EXACT_PRECISION):
        n = matrix.shape[0]
        multiplier = matrix[:, index]
        for j in xrange(index + 1, n, 1):
            v_j = bf.BigFloat(np.float64(vector[j - index - 1]))
            for i in xrange(n):
                matrix[i, j] = bf.add(np.float64(matrix[i, j]), bf.mul(v_j, np.float64(multiplier[i])))
    def interval_bf_operation(self,
                              precision_of_result: int,
                              ad: bool = False):
        self.precision = precision_of_result
        left, right = self.children
        context_down = bf.precision(precision_of_result) + bf.RoundTowardNegative
        context_up = bf.precision(precision_of_result) + bf.RoundTowardPositive
        self.lower = bf.add(left.lower, right.lower, context_down)
        self.upper = bf.add(left.upper, right.upper, context_up)

        if ad:
            left, right = self.children

            left.ad_lower_children.append(((1, 0), self))
            right.ad_lower_children.append(((1, 0), self))

            left.ad_upper_children.append(((0, 1), self))
            right.ad_upper_children.append(((0, 1), self))
    def binary_to_range(self, point: str, precision) -> BigFloat:
        """ Bring a point from [0, 1] to a given range. """
        point = point[:precision + 2]
        interval_width = self.var_upper - self.var_lower
        bitwidth = len(point) - 2
        full_prec_context = bf.precision(bitwidth) + bf.RoundTowardNegative

        # Map to [0, 1]
        value = bf.mul(int(point, 2), bf.exp2(-bitwidth, full_prec_context), full_prec_context)
        rescaled = bf.add(bf.mul(value, interval_width, full_prec_context), self.var_lower, full_prec_context)
        return rescaled
def Decrypt(sk,c,calcZ=True,sk1=1):
    #sk1 is for debugging purpose
    su=0
    if calcZ:
        (c0,z) = c
        for i in range(1,Params.bigo+1):
            if sk[i]!=0:
                su=bigfloat.add(su,z[i],bigfloat.precision(Params.prec))
    else:
        c0 = c
        if Keys.PK==None:
            print "Error: Z vector must be provided when public key not available"
            exit()
        y = Keys.PK[2]
        for i in range(1,Params.bigo+1):
            if sk[i]!=0:
                z = bigfloat.mul(c0,y[i],bigfloat.precision(Params.kappa))
                z = float(bigfloat.mod(z,2,bigfloat.precision(Params.prec)))
                su=bigfloat.add(su,z,bigfloat.precision(Params.prec))
    su=int(bigfloat.round(su))
    m = (c0-su) % 2
    return m
Exemple #13
0
def get_boltzmann_distribution(energy_by_arm):
    R = 8.3144621  # gas constant
    T = 293.15  # room temperature
    factor = 4184.0  # joules_per_kcal
    boltzmann_distribution = []
    for dG in energy_by_arm:
        ps = []
        total = bigfloat.BigFloat(0)
        for energy in dG:
            p = bigfloat.exp((-energy*factor)/(R*T), bigfloat.precision(1000))
            ps.append(p)
            total = bigfloat.add(total, p)
        normal_ps = []
        for p in ps:
            normal_ps.append(float(bigfloat.div(p,total)))
        boltzmann_distribution.append(numpy.array(normal_ps))
    return boltzmann_distribution
def sum_likelihood_result(population):
    """
    Sums all the likelihood results values on a population.

    Args:
        population : LIST[Chromosome(), Chromosome(), ...]
            A list filled with 'Chromosome' objects

    Returns:
        INT
            The sum of all likelihood results on a population
    """
    with bf.quadruple_precision:
        total = bf.BigFloat("0.0")
        for i in range(0, len(population)):
            log_likelihood_result = bf.exp(bf.BigFloat(str(population[i].get_log_likelihood_result())))
            total = bf.add(total, log_likelihood_result)
    return total
def sum_likelihood_result(population):
    """
    Sums all the likelihood results values on a population.

    Args:
        population : LIST[Chromosome(), Chromosome(), ...]
            A list filled with 'Chromosome' objects

    Returns:
        INT
            The sum of all likelihood results on a population
    """
    with bf.quadruple_precision:
        total = bf.BigFloat("0.0")
        for i in range(0, len(population)):
            log_likelihood_result = bf.exp(bf.BigFloat(str(population[i].get_log_likelihood_result())))
            total = bf.add(total, log_likelihood_result)
    return total
def Encrypt(pk,m,calcZ=True,s=None):
    #s is the secret key to be used for debugging purposes
    (pk0,x,y)=pk
    c0 = SomeWhatEncrypt((pk0,x), m)
    if calcZ:
        z=[None]*(Params.bigo+1)
        for i in range(1,Params.bigo+1):
            k=bigfloat.mul(c0,y[i],bigfloat.precision((Params.kappa+Params.gamma)))
            z[i]=float(bigfloat.mod(k,2.0,bigfloat.precision(Params.prec)))
            if z[i]>=2.0:
                z[i]=0
        c = (c0,z)
    else:
        c = c0
    if debug:
        su=0
        for i in range(1,Params.bigo+1):
            if s and s[i]==1:
                su=bigfloat.add(su,z[i],bigfloat.precision(Params.kappa+Params.gamma))
        print "Enc_sum%2=",bigfloat.mod(su,8,bigfloat.precision((Params.prec+Params.gamma)))
        q=bigfloat.div(c0,globsk,bigfloat.precision(Params.kappa+Params.gamma))
        print "(Enc_c/sk)%2=",bigfloat.mod(q,8,bigfloat.precision((Params.prec+Params.gamma)))
        print "c0=",c0
    return c
from bigfloat import sub, add, mul, div, sqr, sqrt, precision

a=1e-8
b=10
c=1e-8
p = 100

D = sub(sqr(b) , mul(4, mul(a,c) ), precision(p))

x1 = div( - add(b , sqrt(D, precision(p))) , mul(2,a), precision(p))
x2 = div( - sub(b , sqrt(D, precision(p))) , mul(2,a), precision(p))

print x1,x2
def KeyGen(Lambda):
    global globsk #For debugginh
    (sk0,pk0)=SomeWhatKeyGen(Lambda)
    globsk = sk0  #For debugging
    #Params.kappa = int(Params.gamma * Params.eta / Params.rho1)
    
    '''Tweak to approximate to nearest integer'''
    t=sk0/2+1
    xp=int((2**Params.kappa+t)/sk0) # Approximating to nearest integer
    S = []
    lenS=0
    while lenS!=Params.theta:
        i=random.randrange(1,Params.bigo)
        if i not in S:
            S.append(i)
            lenS+=1
    s={}
    for i in range(1,Params.bigo+1):
        if i in S:
            s[i]=1
        else:
            s[i]=0
    
    n = 2**(Params.kappa)      
    m = 2**(Params.kappa+1)
    u = {}
    approx = xp/Params.theta
    var = approx/Params.theta
    for i in range(1,Params.bigo+1):
        u[i]=random.randrange(0,m)
    su=0
    for i in S[:-1]:
        x =random.randrange(approx-var,approx+var)
        u[i]=x
        su+=u[i]
    i=S[-1]
    u[i]=xp-su
    
    y={}
    for i in range(1,Params.bigo+1):
        y[i]=bigfloat.div(u[i],n,bigfloat.precision((Params.kappa+Params.gamma)))
    #DEBUG
    if debug:
        su = 0
        su2=0
        for i in S:
            su2+=u[i]
            su=bigfloat.add(su,y[i],bigfloat.precision(Params.kappa+Params.gamma))
            inv = bigfloat.mul(n,y[i],bigfloat.precision(Params.kappa+Params.gamma))
            print u[i]
            print inv
        print "sumxp=",su2
        print "sumf=",su
        print "xp=", xp
        print "xp/n=", bigfloat.div(xp,n,bigfloat.precision(Params.kappa+Params.gamma))
        print "m=",m
        print Params.theta
        print Params.bigo
        print S
        print s
    #END DEBUG
    (pk1,x)=pk0
    pk = (pk1,x,y)
    return (s,pk)
def bunch_kaufman_exact(mtx_origin, alpha=(1. + sqrt(17)) / 8, regularize=False, regularize_coeff=1e-4):
    dtype = mtx_origin.dtype
    mtx = np.array(mtx_origin, dtype=dtype)
    n = mtx.shape[0]
    tridiagonal = np.zeros([3, n], dtype=dtype)
    sum = 0
    cell_sizes = []
    PL = I(n, dtype=dtype)
    flip = False
    while sum < n:
        m = n - sum
        mtx_view = mtx[sum: n, sum: n]
        if sum >= n - 2:
            if sum == n - 2:
                cell_sizes.append(2)
                tridiagonal[1, sum], tridiagonal[1, sum + 1] = mtx_view[0, 0], mtx_view[1, 1]
                tridiagonal[0, sum + 1] = mtx_view[0, 1]
                tridiagonal[2, sum] = mtx_view[1, 0]
            else:
                tridiagonal[1, sum] = mtx_view[0, 0]
            break
        if flip:
            mtx_view[:, :] = mtx_view[::-1, ::-1]
            PL[:, sum:] = PL[:, :sum - 1:-1]
        idx = np.argmax(np.abs(mtx_view.diagonal()))
        swap_indices = (0, idx)
        triangular = I(n, dtype=dtype)
        triangular_view = triangular[sum: n, sum: n]

        exchange_rows(mtx_view, swap_indices[0], swap_indices[1])
        exchange_columns(mtx_view, swap_indices[0], swap_indices[1])
        exchange_columns(PL, swap_indices[0] + sum, swap_indices[1] + sum)

        idx = np.argmax(np.abs(mtx_view[:, 0]))
        lambda_val = abs(mtx_view[:, 0][idx])
        if abs(mtx_view[0, 0]) >= alpha * lambda_val:
            n_k = 1
            swap_indices = (0, 0)
        else:
            testing_column = np.abs(mtx_view[:, idx])
            testing_column[idx] = 0
            j_idx = np.argmax(testing_column)
            sigma_val = testing_column[j_idx]

            if sigma_val * abs(mtx_view[0][0]) >= alpha * lambda_val**2:
                n_k = 1
                swap_indices = (0, 0)
            else:
                if abs(mtx_view[idx][idx]) >= alpha * sigma_val:
                    n_k = 1
                    swap_indices = (0, idx)
                else:
                    n_k = 2
                    assert idx != j_idx, 'please check your factorization. This indices MUST be different'
                    swap_indices = (1, idx)
        if n_k == 2:
            exchange_rows(mtx_view, 0, j_idx)
            exchange_columns(mtx_view, 0, j_idx)
            exchange_columns(PL, sum + 0, sum + j_idx)
        exchange_rows(mtx_view, swap_indices[0], swap_indices[1])
        exchange_columns(mtx_view, swap_indices[0], swap_indices[1])
        exchange_columns(PL, sum + swap_indices[0], sum + swap_indices[1])

        T_k = mtx_view[0:n_k, 0:n_k]
        if n <= sum + n_k:
            if n_k == 1:
                tridiagonal[1, sum] = T_k[0, 0]
            else:
                tridiagonal[1, sum], tridiagonal[1, sum + 1] = T_k[0, 0], T_k[1, 1]
                tridiagonal[0, sum + 1] = T_k[0, 1]
                tridiagonal[2, sum] = T_k[1, 0]
            cell_sizes.append(n_k)
            break
        T_k_inverse = inverse_1_2_exact(T_k, dtype=dtype)
        B_k = mtx_view[n_k: m, 0: n_k]
        triangular_view[n_k: m, 0: n_k] = dot(-B_k, T_k_inverse)

        PL_view = PL[sum:n, sum:n]
        if n_k == 1:
            tridiagonal[1, sum] = T_k[0, 0]
            tri_one = triangular_view[1: m, 0]
            tri_one = -B_k[:, 0] * T_k_inverse[0, 0]
            """print '-'*80
            print 'mtx before left mul'
            print mtx_view"""
            partial_left_one_exact(mtx_view, tri_one, 0)
            """print '-'*80
            print 'mtx before right mul, after left'
            print mtx_view"""
            partial_right_one_exact(mtx_view, tri_one, 0)
            # print '-'*80
            # print 'mtx after right mul'
            # print mtx_view
            # print '-'*80
            mtx_view[1: m, 0] = 0
            mtx_view[0, 1: m] = 0
            # print '-'*80
            # print 'PL before right mul'
            # print PL
            # print '-'*80
            tri_one = -tri_one
            with bf.Context(precision=EXACT_PRECISION):
                for i in xrange(n):
                    ssum = bf.BigFloat(0)
                    for j in xrange(sum + 1, n, 1):
                        ssum = bf.add(ssum, bf.mul(np.float64(PL[i, j]), np.float64(tri_one[j - sum - 1])))

                    PL[i, sum] = bf.add(np.float64(PL[i, sum]), ssum)
                #PL[i, sum] += dot(PL[i, sum + 1:n], (-tri_one))
            # print '-'*80
            # print 'PL after right mul'
            # print PL
            # print '-'*80
        else:
            B_k_minus = -B_k

            tridiagonal[1, sum], tridiagonal[1, sum + 1] = T_k[0, 0], T_k[1, 1]
            tridiagonal[0, sum + 1] = T_k[0, 1]
            tridiagonal[2, sum] = T_k[1, 0]
            tri_one = np.zeros(m)
            tri_two = np.zeros(m)
            for i in xrange(m):
                tri_one[i] = bf.add(bf.mul(B_k_minus[i, 0], T_k_inverse[0, 0]), bf.mul(B_k_minus[i, 1], T_k_inverse[1, 0]))
                tri_two[i] = bf.add(bf.mul(B_k_minus[i, 0], T_k_inverse[0, 1]), bf.mul(B_k_minus[i, 1], T_k_inverse[1, 1]))
            #tri_one = triangular_view[2: m, 0]
            #tri_two = triangular_view[2: m, 1]
            """print '-'*80
            print 'mtx before left mul'
            print mtx_view"""
            partial_left_two_exact(mtx_view, tri_one, tri_two, 0, 1)
            """print '-'*80
            print 'mtx before right mul, after left'
            print mtx_view"""
            partial_right_two_exact(mtx_view, tri_one, tri_two, 0, 1)
            """print '-'*80
            print 'mtx after right mul'
            print mtx_view
            print '-'*80"""
            mtx_view[2: m, [0, 1]] = 0
            mtx_view[[0, 1], 2: m] = 0
            """print '-'*80
            print 'PL before right mul'
            print PL
            print '-'*80"""
            with bf.Context(precision=EXACT_PRECISION):
                tri_one = -tri_one
                tri_two = -tri_two
                for i in xrange(n):
                    ssum1 = bf.BigFloat(0)
                    ssum2 = bf.BigFloat(0)
                    for j in xrange(sum + 2, n, 1):
                        ssum1 = bf.add(ssum1, bf.mul(PL[i, j], tri_one[j - sum - 2]))
                        ssum2 = bf.add(ssum2, bf.mul(PL[i, j], tri_two[j - sum - 2]))

                    PL[i, sum] = bf.add(PL[i, sum], ssum1)
                    PL[i, sum + 1] = bf.add(PL[i, sum + 1], ssum2)
            """print '-'*80
            print 'PL after right mul'
            print PL
            print '-'*80"""
        sum += n_k
        cell_sizes.append(n_k)
        #flip = not flip
    #print 'ASSEMBLED:'
    #print dot(dot(PL, mtx), np.matrix(PL).getH())
    P, L = separate_permutation(PL, dtype=dtype)

    return P, L, cell_sizes, tridiagonal