示例#1
0
print "Opened %s" % sys.argv[1]

out = open(sys.argv[2], "w+")
print "Output will be written to %s" % sys.argv[2]

if (k == 0):
    print "Currently Configured to sum along the COLUMN"
else:
    print "Currently Configured to sum along the ROW"

n = matrix.shape[0]
print "Normalizing Input Matrix along ",
if (k == 0):
    print "each column"
else:
    print "each row"

Norm = matrixFunctions2d.normalize2dMatrix(matrix, k)
#print Norm
logd = logm(Norm)
print logd
diag = matrixFunctions2d.diagonalAdjustment2d(logd)

#print free energy to f.txt
matrixFunctions2d.printDetailedBalanceftxt(diag,
                                           "diagonal_db_%s.dat" % sys.argv[1])
matrixFunctions2d.write2dMatrix(diag, "diagonal_Matrix_%s.dat" % sys.argv[1])
#detailed balance

#matrixFunctions2d.print2dMatrix(diag)
示例#2
0
#!/usr/bin/python
import sys
import numpy as np
import matrixFunctions2d
from scipy.linalg import expm, logm

matrix = matrixFunctions2d.read2dMatrix(sys.argv[1])

Norm = matrixFunctions2d.normalize2dMatrix(matrix, 0)
logd = logm(Norm)

#mat = expm(matrix)
#matrixFunctions2d.printDetailedBalanceftxt(mat, "quickout.txt")
matrixFunctions2d.printDetailedBalanceftxt(
    logd, "detailedBalance_%s.dat" % sys.argv[1])
#matrixFunctions2d.printDetailedBalanceftxt(matrix, "quickout.txt")
示例#3
0
print "Opened %s" % sys.argv[1]

out = open(sys.argv[2], "w+")
print "Output will be written to %s" % sys.argv[2]

if (k == 0):
    print "Currently Configured to sum along the COLUMN"
else:
    print "Currently Configured to sum along the ROW"

n = matrix.shape[0]
print "Normalizing Input Matrix along ",
if (k == 0):
    print "each column"
else:
    print "each row"

Norm = matrixFunctions2d.normalize2dMatrix(matrix, k)
#print Norm
log = logm(Norm)
adjusted = matrixFunctions2d.weightedAdjustment2d(log, k)

exp = expm(adjusted)

matrixFunctions2d.printDetailedBalanceftxt(adjusted,
                                           "weighted_db_%s.dat" % sys.argv[1])
matrixFunctions2d.write2dMatrix(adjusted,
                                "weighted_Matrix_%s.dat" % sys.argv[1])

#matrixFunctions2d.print2dMatrix(adjusted)
示例#4
0
norm = matrixFunctions2d.normalize2dMatrix(mat, 1)#along row
log = logm(norm)
Q = matrixFunctions2d.diagonalAdjustment2d(log)    #this is our Qnaught
#Q = matrixFunctions2d.weightedAdjustment2d(log)
def func(x, i, j, Q):
   P = expm(Q)
   n = Q.shape[0]
   copy = np.copy(Q)
   for k in range(n):
      diff = Q[i,j] - x#initially zero for first iteration, should change as x changes
      for u in range(n):
         if(u!=j):
            copy[i,u] += float(diff/n)

      copy[i,i] = -1 * (np.sum(copy[i,:]) - copy[i,i]) #set diagonal to neg sum
   return distance(copy, Q) 

n = norm.shape[0]
q = np.copy(Q) 
for i in range(n):
   for j in range(n):
      if(i!=j):
         calculations+=1
         print calculations
         q[i,j] = optimize.fmin(func, Q[i,j], args=(i,j,Q))#argmin(i, j, Q, c)
         print q[i,j]
         Q = np.copy(q) #put updated matrix in place of Q

matrixFunctions2d.printDetailedBalanceftxt(np.transpose(Q), "componentwise_%s.dat"%sys.argv[1])
示例#5
0
         elif(j==0):
            Sort[j,i] = Sort[j,i] + l[i]
         else:
            Sort[j,i] = Sort[j,i] + l[i]



#matrixFunctions2d.print2dMatrix(Sort)

#use Unsort Matrix to get final output


final = np.zeros((n,n))
if(k==1):
   for i in range(n):
      for j in range(n):
         final[i,j] = Sort[i,int(Unsort[i,j])-1]
else:
   for i in range(n):
      for j in range(n):
         final[j,i] = Sort[int(Unsort[j,i])-1,i]
#print
#print
#matrixFunctions2d.print2dMatrix(Unsort)
#print
#print
#matrixFunctions2d.print2dMatrix(final)
matrixFunctions2d.printDetailedBalanceftxt(final, "QOG_DB_%s.dat"%sys.argv[1])

matrixFunctions2d.write2dMatrix(final, "QOG_mat_%s.dat"%sys.argv[1])
示例#6
0
xval = 4
niters = 1000
deltaT = 1  #number of times to jump through prior before moving to next step
repeats = 100
while (nGibbs > 0):
    print "Gibbs Iteration: ", totalIters - nGibbs
    nGibbs -= 1
    samples, accepted, totalCount = metropolis.metropolisHastings(
        niters, repeats, n, distribution, deltaT,
        metropolis.transitionProbSimple, metropolis.stepGenerator,
        Q)  #Draw Samples Using Q
    N = metropolis.samplesToN(samples, n)
    N = matrixFunctions2d.normalize2dMatrix(N, 0)  #normalize along row
    for i in range(n):
        for j in range(n):
            if (N[i, j] == 0):
                N[i, j] = val
            Q[i, j] = gammaFunction(N[i, i], N[i, j],
                                    alpha[i, j])  #Use Samples to make new Q
    for i in range(n):
        Q[i, i] = -1.0 * (np.sum(Q[i, :]) - Q[i, i])
    #repeat

    matrixFunctions2d.write2dMatrix(
        N, "gibbs_matrix_%s_%s.dat" % (sys.argv[1], totalIters - nGibbs))
    matrixFunctions2d.printDetailedBalanceftxt(
        N, "gibbs_db_%s_%s.dat" % (sys.argv[1], totalIters - nGibbs),
        "#Number of Iterations : %s" % sys.argv[2])
#   counts = metropolis.countSamples(samples, n)
#   metropolis.printCounts(fname, totalCount, accepted, n, counts, xval)
示例#7
0
from scipy.linalg import expm, logm

mat = matrixFunctions2d.read2dMatrix(sys.argv[1])
tau = int(sys.argv[2])

kb = 0.0019872041
T = 298
kbT = kb * T
#print kbT
beta = 1 / kbT
#print beta
binWidth = 0.083333

#edit, first calculate DB statistics, then D(x), then double sum for an answer
#calculate DB
f = matrixFunctions2d.printDetailedBalanceftxt(mat, "temp")
#print f[11], f[35] Our -1, 1 are at 11/35 respectivelyi
lower = 11
upper = 35
adjustment = 1  #the F index is off by one
lower = 12
upper = 36
adjustment = 0
P = expm(0.000001 * mat)
f = np.zeros(P.shape[0])
sumd = 0
for i in range(P.shape[0]):
    sumd += P[i, i]
for i in range(P.shape[0]):
    f[i] = P[i, i] / sumd
for i in range(40):