def analyze(self, sw=100):
#Recalculate everything
self.calc()
vals = sp.vstack((self.beta_hat.T,self.deviation, self.tstats, self.pvals)).T
print "Analyze".center(sw, "=")
print ("\tAlpha = %.3f" % self.alpha)
print ("\tDecision rule = %.5f" % self.drule)
print ("\tR**2 adjusted = %.5f" % self.r2a())
#temporaily set scipy pretty print options
#sp.set_printoptions(precision=5, linewidth=sw, suppress=True)
print "\tBeta\tDev\tT-stats\tP-vals"
for irow in xrange(self.Xdim):
if self.vtags.has_key(irow):
label = self.vtags[irow][:7]
else:
label = str(irow)
print "%s\t" % label,"\t".join([("%.5f"%v)[:7] for v in vals[irow,:]])
#print " Alpha: %.3f" % self.alpha
#print " Decision rule: %.5f" %self.drule
#print " beta dev tstats pvals"
#print
#return
sp.set_printoptions()
def main_loop(self):
sp.set_printoptions(precision=16)
it = 0
while it <= 1000:
print("\n\n=====================================================")
print("cycle = ", self.cycle, "it = ", it)
print("=====================================================")
# if it > self.maxs:
if it > 40:
sys.exit("Exceeded maximum number of iterations. ABORTING!")
if self.cycle > 2:
sys.exit("got to cycle 3, exit")
for iev in range(self.nev):
self.iev = iev
self.extend_right_handed_spaces(iev)
if self.cycle > 1:
self.extend_left_handed_spaces(iev)
it = it + 1
# Build subspace matrix : v*Av = v*w
submat = self.build_subspace_matrix()
dnorm = self.get_residual_vectors(submat)
skip = np.ndarray(self.nev, np.bool)
for ii in range(self.nev):
if dnorm[ii] <= self.threshold:
skip[ii] = True
else:
skip[ii] = False
print("self.teta = ", self.teta)
if False in skip[:self.nev]:
print("Not converged on iteration ", it)
print("dnorm = ", dnorm, "skip = ", skip)
else:
print("Final eigenvalues = ",
self.real_precision(self.teta[:self.nev]))
sys.exit("Converged!!")
self.cycle = self.cycle + 1
def estimate_dispersion_chunk(gene_counts, matrix, sf, options, test_idx, idx, log=False):
disp_raw = sp.empty((idx.shape[0], 1), dtype='float')
disp_raw.fill(sp.nan)
disp_raw_conv = sp.zeros((idx.shape[0], 1), dtype='bool')
npr.seed(23)
for i in range(idx.shape[0]):
if log:
log_progress(i, idx.shape[0])
disp = 0.1
resp = gene_counts[i, :].astype('int')
if sum(resp / sf) < options.min_count or sp.mean(resp == 0) > 0.6 or not test_idx[i]:
continue
for j in range(10):
modNB = sm.GLM(resp, matrix, family=sm.families.NegativeBinomial(alpha=disp), offset=sp.log(sf))
result = modNB.fit()
sp.set_printoptions(12)
last_disp = disp
yhat = result.mu
sign = -1.0
with warnings.catch_warnings():
warnings.simplefilter("ignore")
res = minimize_scalar(likelihood.adj_loglikelihood_scalar, args=(matrix, resp, yhat, sign), method='Bounded', bounds=(0, 10.0), tol=1e-5)
disp = res.x
if abs(sp.log(disp) - sp.log(last_disp)) < 1e-4:
disp_raw[i] = disp
disp_raw_conv[i] = True
break
else:
disp_raw[i] = disp
disp_raw_conv[i] = False
if log:
log_progress(idx.shape[0], idx.shape[0])
return (disp_raw, disp_raw_conv, idx)
def main_routine (filelist,writeCnt=8,readCnt=16):
files = [line.rstrip('\n') for line in open(filelist)]
coeffs = sp.zeros([2*writeCnt+readCnt,len(files)],complex)
nRead=readCnt
nDown=nRead+writeCnt
nUp =nDown+writeCnt
texDown=writeCnt
texUp =texDown+writeCnt
texRead=texUp+readCnt
myFmt = ""
for i in sp.arange(len(files)) :
filename=files[i]
print "read: " + filename
if (myFmt != ""):
myFmt += " & "
myFmt = myFmt + "$%.3f %+.3f~\im$"
reGamma,imGamma=sp.loadtxt(filename).T
alphaR =reGamma[0:nRead] +1j*imGamma[0:nRead]
alphaD =reGamma[nRead:nDown]+1j*imGamma[nRead:nDown]
alphaU =reGamma[nDown:nUp] +1j*imGamma[nDown:nUp]
coeffs[ 0:texDown,i]=alphaD
coeffs[texDown:texUp ,i]=alphaU
coeffs[texUp :texRead,i]=alphaR
myFmt = "$\\alpha^{}_{}$ & " + myFmt + "\\\\"
sp.set_printoptions(precision=3)
sp.savetxt(filelist+".tbl",coeffs,delimiter="&",fmt=myFmt)
# Import Standard Libraries
import time
import logging
import argparse
import scipy as np
# Import Local Libraries
from properties import Properties
from modules import ChainModule
from modules import InputModule
from modules import InitModule
from modules import NonlinModule
from modules import SampleModule
from modules import ControlModule
from modules import Execute
np.set_printoptions(precision=4)
def main():
logging.basicConfig(level=logging.INFO, format='%(message)s')
parser = argparse.ArgumentParser()
parser.add_argument("file_path", help="Path to properties file", type=str)
file = parser.parse_args().file_path
start = time.time()
# Props & Globdat
conf = Properties()
props = Properties()
globdat = Properties()
props.parseFile(file)
###############################################################################
import sys, itertools, scipy
from scipy import array, arange, ones, zeros
from scipy import exp, sqrt, pi, fabs, ceil
from scipy import set_printoptions
from scipy.special import j1
from scipy.misc import imresize
from scipy.ndimage.interpolation import affine_transform
from Image import fromarray
from Pickets import Pickets
from Report import Report
###############################################################################
set_printoptions(precision=2, suppress=True, linewidth=150)
###############################################################################
class Human(Report):
aawf = {'radius' : 0e+0,
'amplitude' : 1e+0,
'aperture' : 1e-3,
'wavelength': 4e-7,
'focal' :17e-3}
zeroPoints = [ # u values where Airy goes to zero, discovered by hand.
3.83170611001,
7.01558711101,
10.1734711001, # Maximum kernel radius parameter.
# u = (pi*r*a) / (w*f) where:
# r radius kernel max
def __str__(self):
sp.set_printoptions(precision=8)
return self.defCurveXYZ.__str__()
from dynamics.object import Rectangle, Circle, Beam
from dynamics.constraint import Nail, Rod, Pin, Shelf
from dynamics.animation import Animation
from dynamics.constants import foot2meter, inch2meter, meter2foot
from dynamics.misc import length_, rot2radians, radians2rot
from dynamics.constants import lb2kgram, kgram2lb, newton2lb
from dynamics.constants import pine_density, steel_density
import scipy
import scipy.interpolate
import numpy as np
from math import pi, sin, cos, sqrt, acos, atan2
from scipy.optimize.minpack import fsolve
scipy.set_printoptions(precision=5, linewidth=200)
def continue_sim(sim, time, y):
"continue simulation?"
return True
sim_duration = 2.0
time_step = 0.001
debug = True
sim = dynamics.simulation.Simulation(max_time=sim_duration,
time_step=time_step)
sim.debug=debug
hinge_pos = (0.0, 0.0)
cw_mass = lb2kgram(2000.)
ramp_length = foot2meter(10.)
import cPickle as pickle
import csv
import re
import scipy
import pylab
__author__ = 'marrabld'
import pidly # Use this to call one of DIMITRI's IDL functions and pass back the data structure
##!! This is required to prevent unwanted linefeeds in the csv file
scipy.set_printoptions(linewidth=2000)
class DimitriSatelliteObject():
def __init__(self, gdl_path='/usr/bin/gdl'):
self.idl = pidly.IDL(gdl_path, idl_prompt='GDL> ')
self.l1b_data = None
self.bands = {
'PARASOL': ['443', '490p', '490u', '490q', '565', '670p', '670u', '670q', '763', '765', '865p', '865u',
'865q', '910', '1020'],
'MERIS': ['412', '443', '490', '510', '560', '620', '665', '681', '708', '753', '761', '778',
'865', '885', '900']} ## !!! these are the same as DIMITRI FOR NOW!! CHECK
self.sensor_name = 'PARASOL'
self.num_bands = 16
def read_satellite_file(self,
## finite difference for 2d grid.
## set up
import scipy as sp
sp.set_printoptions(precision = 2, suppress = True, linewidth=200)
## suggested... Tb = 176, Ti = 26, c1 = 3, c2 = .17, w = 1
## step forward
def u_next(S,i,j,c, delta_t, delta_s,m,n):
return S[i,j] + c*delta_t/delta_s**2*(S[min(i+1,m-1),j] + S[max(i-1,0),j] - 4*S[i,j] + S[i, min(j+1,n-1)] + S[i,max(j-1,0)])
#bindM will maintain boundary conditions
def bindM(S, Tb):
M = S.copy()
m = M.shape[0]
n = M.shape[1]
for i in range(m):
for j in range(n):
M[i,0] = M[0,j] = M[m-1,j] = M[i,n-1] = Tb
return M
# sets up initial conditions
def init_con(In, Ti,w):
m= In.shape[0]
n = In.shape[1]
for i in range(m):
for j in range(n):
if (i >= w and j >= w) and (i < m-1 and j < n-1):
In[i,j] = Ti
def heating_up(m,n, tf, c1, c2,w, Ti, Tb,delta_t,outputfile):
# define spatial mesh
S = sp.zeros(m*n).reshape(m,n)
left = PML_WIDTH
right = SIZE_X - PML_WIDTH
# Permittivity and permeability of PML
MU_R = 1
EPSILON_R = 1
muR = sp.ones((SIZE_X, SIZE_Y))
muR[:, bottom:top] *= MU_R
epsR = sp.ones((SIZE_X, SIZE_Y))
epsR[:, bottom:top] *= EPSILON_R
# Electric and magnetic losses
LOSS_X = 0.00025 * (sp.mgrid[0:PML_WIDTH, 0:SIZE_Y][0]**2)
LOSS_Y = 0.00025 * (sp.mgrid[0:SIZE_X, 0:PML_WIDTH][1]**2)
sp.set_printoptions(precision=2,
threshold=sp.nan,
linewidth=135,
suppress=True)
print LOSS_X
loss_x = sp.zeros((SIZE_X, SIZE_Y))
loss_y = sp.zeros((SIZE_X, SIZE_Y))
loss_x[right:, :] += LOSS_X
loss_x[:left, :] += LOSS_X[::-1, :]
loss_y[:, top:] += LOSS_Y
loss_y[:, :bottom] += LOSS_Y[:, ::-1]
# Coefficients multiplying Hx and Ez for the Hx update
chx_loss_y = (loss_y[:, 1:] + loss_y[:, :-1]) / 2
chx_muR = (muR[:, 1:] + muR[:, :-1]) / 2
chxh = (1 - chx_loss_y) / (1 + chx_loss_y)
chxe = -Sc_y / (chx_muR * imp0 * (1 + chx_loss_y))
# Coefficients multiplying Hy and Ez for the Hy update
def setupPrint():
sp.set_printoptions(edgeitems=3,
linewidth=400,
precision=16,
suppress=False,
threshold=10000)
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import sys, scipy, itertools
scipy.set_printoptions(precision=3, suppress=True, linewidth=100)
class Pickets(object):
def __init__(self, radial=1):
self.radial = radial
div1 = 1 + 2 * radial
div2 = 1 if radial < 1 else 2 + 1.0 / radial
seq = [0] if radial == 0 else scipy.linspace(-1.0, 1.0, div1) / div2
if len(seq) > 1:
"""Assert that the pickets are evenly spaced."""
one = 2 * seq[-1] + seq[1 + len(seq) / 2]
epsilon = scipy.fabs(1.0 - one)
assert epsilon < 1e-10
self.pickets = list(itertools.product(seq, repeat=2))
def get_numpy_evals(self):
evals, evecs_l, evecs = sp_la.eig(self.mat_orig, left=True)
sp.set_printoptions(threshold=sys.maxsize)
print("numpy evals =\n ", sorted(abs(sp.real(evals)), reverse=False))
bottom = PML_WIDTH left = PML_WIDTH right = SIZE_X - PML_WIDTH # Permittivity and permeability of PML MU_R = 1 EPSILON_R = 1 muR = sp.ones((SIZE_X, SIZE_Y)) muR[:, bottom:top] *= MU_R epsR = sp.ones((SIZE_X, SIZE_Y)) epsR[:, bottom:top] *= EPSILON_R # Electric and magnetic losses LOSS_X = 0.00025 * (sp.mgrid[0:PML_WIDTH, 0:SIZE_Y][0] ** 2) LOSS_Y = 0.00025 * (sp.mgrid[0:SIZE_X, 0:PML_WIDTH][1] ** 2) sp.set_printoptions(precision = 2, threshold = sp.nan, linewidth = 135, suppress = True) print LOSS_X loss_x = sp.zeros((SIZE_X, SIZE_Y)) loss_y = sp.zeros((SIZE_X, SIZE_Y)) loss_x[right:, :] += LOSS_X loss_x[:left, :] += LOSS_X[::-1, :] loss_y[:, top:] += LOSS_Y loss_y[:, :bottom] += LOSS_Y[:, ::-1] # Coefficients multiplying Hx and Ez for the Hx update chx_loss_y = (loss_y[:, 1:] + loss_y[:, :-1]) / 2 chx_muR = (muR[:, 1:] + muR[:, :-1]) / 2 chxh = (1 - chx_loss_y) / (1 + chx_loss_y) chxe = - Sc_y / (chx_muR * imp0 * (1+chx_loss_y)) # Coefficients multiplying Hy and Ez for the Hy update chy_loss_x = (loss_x[1:, :] + loss_x[:-1, :]) / 2
# DSGE Homework: Lab 5b # <headingcell level=4> # Import Statements # <codecell> import scipy as sp import sympy as sym from sympy import symbols, nsolve, Symbol # <codecell> sp.set_printoptions(linewidth=140, precision=4) # <headingcell level=4> # Parameter Definitions # <codecell> gamma = 2.5 xsi= 1.5 beta = 0.98 alpha = 0.4 a = 0.5 delta = 0.10 zbar = 0 tao = 0.05
if terminal: break
elif abs(vn) <= abs(v0) >= abs(vp):
Airy.peaks += [val0,]
"Find a below epsilon peak"
if abs(val0['amplitude']) < epsilon: terminal = True
valn, val0 = val0, valp
Airy() # Generate singleton
if __name__ == "__main__":
def test1(): print len(Airy.zeros), "zeros"
def test2(): print Airy.zeros[0]['parameter'], Airy.point[1]['amplitude']
def test3(): print string.join(["%1.16e, %1.16e" % (u,am) for (u,am) in Airy.spike], '\n')
def test4(): print Airy.zeros[0]['parameter']/Airy.r0
def runtest(key, val): print '\t%s' %(key); val()
tests = {"zerocount": test1, "firstzero": test2, "spikes": test3, "u0/r0": test4}
parser = OptionParser()
parser.add_option("-d", "--delta", default=1e-7, help="radial step size")
parser.add_option("-e", "--epsilon", default=1e-3, help="lower cutoff for kernel")
parser.add_option("-l", "--linewidth", default=1000, help="print width")
parser.add_option("-p", "--precision", default=2, help="print precision")
(opts, args) = parser.parse_args()
kwargs = vars(opts)
set_printoptions(precision=kwargs.get('precision',2), linewidth=kwargs.get('linewidth', 1000))
[runtest(key,val) for (key,val) in tests.iteritems()]
import scipy as sp
import scipy.linalg as spla
import scipy.sparse as sps
import scipy.sparse.linalg as spsla
import time
from householder import lcd, householder
sp.set_printoptions(edgeitems=30, linewidth=100000)
def gmres(A: sp.matrix, b: sp.matrix, x_0: sp.matrix=None):
start = time.time()
m, n = A.shape
r = b - A @ x_0
r_0_norm = spla.norm(r)
b_norm = spla.norm(b)
H = sp.ndarray((1, 0))
Q = r / spla.norm(r)
Q.reshape((n, 1))
k = 0
while True:
k += 1
# print(H.shape)
h = sp.ndarray((k, 1))
j = k
q_j = Q[:,j-1]
z = A @ q_j
for i in range(j):
def dumpXML(seedname):
import time
S.set_printoptions(threshold=S.nan) #don't skip printing parts of the array
if os.path.isfile(seedname+"-geomopt1.cml"):
# we'll inject the data into this file, then
basefile = seedname+"-geomopt1.cml"
print "Inserting CML into: "+ basefile
f = open(basefile, "r")
tree = etree.parse(f)
f.close()
fp = d["{http://www.castep.org/cml/dictionary/}finalProperties"]
finalproperties = fp.findin_context(tree)
assert len(finalproperties) == 1
startnode = finalproperties[0]
elif os.path.isfile(seedname+"-energy.cml"):
# we'll inject the data into this file, then
basefile = seedname+"-energy.cml"
print "Inserting CML into: "+ basefile
f = open(basefile, "r")
tree = etree.parse(f)
f.close()
fp = d["{http://www.castep.org/cml/dictionary/}finalProperties"]
finalproperties = fp.findin_context(tree)
assert len(finalproperties) == 1
startnode = finalproperties[0]
else:
basefile = seedname+"_cij_analysis.cml"
print "Outputting CML into: "+ basefile
# create a header
CML_NAMESPACE = "http://www.xml-cml.org/schema"
DC_NAMESPACE ="http://purl.org/dc/elements/1.1/"
CML = "{%s}" % CML_NAMESPACE
NSMAP = {None : CML_NAMESPACE, "dc" : DC_NAMESPACE}
startnode = etree.Element(CML +"cml", nsmap=NSMAP)
metadata = etree.Element("metadata")
metadata.attrib["name"] = "dc:date"
metadata.attrib["content"] = time.strftime("%Y-%m-%dT%H:%M:%S")
startnode.append(metadata)
metadata = etree.Element("metadata")
metadata.attrib["name"] = "dc:creator"
metadata.attrib["content"] = "MGElastics"
startnode.append(metadata)
metadata = etree.Element("metadata")
metadata.attrib["name"] = "dc:hasVersion"
metadata.attrib["content"] = str(version)
startnode.append(metadata)
metadata = etree.Element("metadata")
metadata.attrib["name"] = "dc:subject"
metadata.attrib["content"] = "Analysis file for Cij calculations"
startnode.append(metadata)
tree = etree.ElementTree(startnode)
# now append Cij data
cijnode = etree.Element("propertyList")
cijnode.attrib["title"] = "MaterialsGrid: Elastic Properties"
cijnode.attrib["dictRef"] = "castep:elastic_properties"
startnode.append(cijnode)
cijProp = etree.Element("property")
cijProp.attrib["dictRef"] = "castep:elastic_stiffness_constants"
cijProp.attrib["title"] = "Elastic Stiffness Constants"
cijnode.append(cijProp)
cijTensor = etree.Element("matrix")
cijTensor.attrib["rows"] = "6"
cijTensor.attrib["columns"] = "6"
cijTensor.attrib["dataType"] = "xsd:double"
cijTensor.attrib["units"] = "castepunits:"+ units.lower()
cijTensor.text = S.array2string(finalCijMatrix.reshape(1,36)[0],max_line_width=1000,suppress_small=True).strip("[] ")
cijProp.append(cijTensor)
sijProp = etree.Element("property")
sijProp.attrib["dictRef"] = "castep:elastic_compliance_constants"
sijProp.attrib["title"] = "Elastic Compliance Constants"
cijnode.append(sijProp)
sijTensor = etree.Element("matrix")
sijTensor.attrib["rows"] = "6"
sijTensor.attrib["columns"] = "6"
sijTensor.attrib["dataType"] = "xsd:double"
sijTensor.attrib["units"] = "castepunits:"+ units.lower()+"-1" #this has to be changed - i don't think the '/' is allowed
sijTensor.text = S.array2string(sij.reshape(1,36)[0],max_line_width=1000,suppress_small=True).strip("[] ")
sijProp.append(sijTensor)
#### Young's Moduli ####
youngsMod = etree.Element("propertyList")
youngsMod.attrib["dictRef"] = "castep:youngs_moduli"
youngsMod.attrib["title"] = "Young's Moduli"
cijnode.append(youngsMod)
# X
youngsModValX = etree.Element("property")
youngsModValX.attrib["title"] = "Young's Modulus X"
youngsModValX.attrib["dictRef"] = "castep:young_x"
youngsMod.append(youngsModValX)
youngsModValXScalar = etree.Element("scalar")
youngsModValXScalar.attrib["dataType"] = "xsd:double"
youngsModValXScalar.attrib["units"] = "castepunits:"+ units.lower()
youngsModValXScalar.text = str(youngX)
youngsModValX.append(youngsModValXScalar)
# Y
youngsModValY = etree.Element("property")
youngsModValY.attrib["title"] = "Young's Modulus Y"
youngsModValY.attrib["dictRef"] = "castep:young_y"
youngsMod.append(youngsModValY)
youngsModValYScalar = etree.Element("scalar")
youngsModValYScalar.attrib["dataType"] = "xsd:double"
youngsModValYScalar.attrib["units"] = "castepunits:"+ units.lower()
youngsModValYScalar.text = str(youngY)
youngsModValY.append(youngsModValYScalar)
# Z
youngsModValZ = etree.Element("property")
youngsModValZ.attrib["title"] = "Young's Modulus Z"
youngsModValZ.attrib["dictRef"] = "castep:young_z"
youngsMod.append(youngsModValZ)
youngsModValZScalar = etree.Element("scalar")
youngsModValZScalar.attrib["dataType"] = "xsd:double"
youngsModValZScalar.attrib["units"] = "castepunits:"+ units.lower()
youngsModValZScalar.text = str(youngZ)
youngsModValZ.append(youngsModValZScalar)
#### Poisson's Ratio ####
poissonMod = etree.Element("propertyList")
poissonMod.attrib["dictRef"] = "castep:poisson_ratio"
poissonMod.attrib["title"] = "Poisson Ratio"
cijnode.append(poissonMod)
# XY
poissonModValXY = etree.Element("property")
poissonModValXY.attrib["title"] = "Poisson Ratio XY"
poissonModValXY.attrib["dictRef"] = "castep:poisson_xy"
poissonModValXY.attrib["units"] = "castepunits:dimensionless"
poissonMod.append(poissonModValXY)
poissonModValXYScalar = etree.Element("scalar")
poissonModValXYScalar.attrib["dataType"] = "xsd:double"
poissonModValXYScalar.attrib["units"] = "castepunits:dimensionless"
poissonModValXYScalar.text = str(poissonXY)
poissonModValXY.append(poissonModValXYScalar)
# XZ
poissonModValXZ = etree.Element("property")
poissonModValXZ.attrib["title"] = "Poisson Ratio XZ"
poissonModValXZ.attrib["dictRef"] = "castep:poisson_xz"
poissonMod.append(poissonModValXZ)
poissonModValXZScalar = etree.Element("scalar")
poissonModValXZScalar.attrib["dataType"] = "xsd:double"
poissonModValXZScalar.attrib["units"] = "castepunits:dimensionless"
poissonModValXZScalar.text = str(poissonXZ)
poissonModValXZ.append(poissonModValXZScalar)
# YX
poissonModValYX = etree.Element("property")
poissonModValYX.attrib["title"] = "Poisson Ratio YX"
poissonModValYX.attrib["dictRef"] = "castep:poisson_yx"
poissonMod.append(poissonModValYX)
poissonModValYXScalar = etree.Element("scalar")
poissonModValYXScalar.attrib["dataType"] = "xsd:double"
poissonModValYXScalar.attrib["units"] = "castepunits:dimensionless"
poissonModValYXScalar.text = str(poissonYX)
poissonModValYX.append(poissonModValYXScalar)
# YZ
poissonModValYZ = etree.Element("property")
poissonModValYZ.attrib["title"] = "Poisson Ratio YZ"
poissonModValYZ.attrib["dictRef"] = "castep:poisson_yz"
poissonMod.append(poissonModValYZ)
poissonModValYZScalar = etree.Element("scalar")
poissonModValYZScalar.attrib["dataType"] = "xsd:double"
poissonModValYZScalar.attrib["units"] = "castepunits:dimensionless"
poissonModValYZScalar.text = str(poissonYZ)
poissonModValYZ.append(poissonModValYZScalar)
# ZX
poissonModValZX = etree.Element("property")
poissonModValZX.attrib["title"] = "Poisson Ratio ZX"
poissonModValZX.attrib["dictRef"] = "castep:poisson_zx"
poissonMod.append(poissonModValZX)
poissonModValZXScalar = etree.Element("scalar")
poissonModValZXScalar.attrib["dataType"] = "xsd:double"
poissonModValZXScalar.attrib["units"] = "castepunits:dimensionless"
poissonModValZXScalar.text = str(poissonZX)
poissonModValZX.append(poissonModValZXScalar)
# ZY
poissonModValZY = etree.Element("property")
poissonModValZY.attrib["title"] = "Poisson Ratio ZY"
poissonModValZY.attrib["dictRef"] = "castep:poisson_zy"
poissonMod.append(poissonModValZY)
poissonModValZYScalar = etree.Element("scalar")
poissonModValZYScalar.attrib["dataType"] = "xsd:double"
poissonModValZYScalar.attrib["units"] = "castepunits:dimensionless"
poissonModValZYScalar.text = str(poissonZY)
poissonModValZY.append(poissonModValZYScalar)
#### Polycrystalline Results ####
#bulk moduli
bulkModPL = etree.Element("propertyList")
bulkModPL.attrib["dictRef"] = "castep:polycrystalline_bulk_moduli"
bulkModPL.attrib["title"] = "Polycrystalline Bulk Moduli"
cijnode.append(bulkModPL)
bulkModVoigt = etree.Element("property")
bulkModVoigt.attrib["title"] = "Voigt"
bulkModVoigt.attrib["dictRef"] = "castep:bulk_modulus_voigt"
bulkModPL.append(bulkModVoigt)
bulkModReuss = etree.Element("property")
bulkModReuss.attrib["title"] = "Reuss"
bulkModReuss.attrib["dictRef"] = "castep:bulk_modulus_reuss"
bulkModPL.append(bulkModReuss)
bulkModHill = etree.Element("property")
bulkModHill.attrib["title"] = "Hill"
bulkModHill.attrib["dictRef"] = "castep:bulk_modulus_hill"
bulkModPL.append(bulkModHill)
bulkModVoigtScalar = etree.Element("scalar")
bulkModVoigtScalar.attrib["dataType"] = "xsd:double"
bulkModVoigtScalar.attrib["units"] = "castepunits:"+ units.lower()
bulkModVoigtScalar.text = str(voigtB)
bulkModVoigt.append(bulkModVoigtScalar)
bulkModReussScalar = etree.Element("scalar")
bulkModReussScalar.attrib["dataType"] = "xsd:double"
bulkModReussScalar.attrib["units"] = "castepunits:"+ units.lower()
bulkModReussScalar.text = str(reussB)
bulkModReuss.append(bulkModReussScalar)
bulkModHillScalar = etree.Element("scalar")
bulkModHillScalar.attrib["dataType"] = "xsd:double"
bulkModHillScalar.attrib["units"] = "castepunits:"+ units.lower()
bulkModHillScalar.text = str((voigtB+reussB)/2)
bulkModHill.append(bulkModHillScalar)
#shear moduli
shearModPL = etree.Element("propertyList")
shearModPL.attrib["dictRef"] = "castep:polycrystalline_shear_moduli"
shearModPL.attrib["title"] = "Polycrystalline Shear Moduli"
cijnode.append(shearModPL)
shearModVoigt = etree.Element("property")
shearModVoigt.attrib["title"] = "Voigt"
shearModVoigt.attrib["dictRef"] = "castep:shear_modulus_voigt"
shearModPL.append(shearModVoigt)
shearModReuss = etree.Element("property")
shearModReuss.attrib["title"] = "Reuss"
shearModReuss.attrib["dictRef"] = "castep:shear_modulus_reuss"
shearModPL.append(shearModReuss)
shearModHill = etree.Element("property")
shearModHill.attrib["title"] = "Hill"
shearModHill.attrib["dictRef"] = "castep:shear_modulus_hill"
shearModPL.append(shearModHill)
shearModVoigtScalar = etree.Element("scalar")
shearModVoigtScalar.attrib["dataType"] = "xsd:double"
shearModVoigtScalar.attrib["units"] = "castepunits:"+ units.lower()
shearModVoigtScalar.text = str(voigtG)
shearModVoigt.append(shearModVoigtScalar)
shearModReussScalar = etree.Element("scalar")
shearModReussScalar.attrib["dataType"] = "xsd:double"
shearModReussScalar.attrib["units"] = "castepunits:"+ units.lower()
shearModReussScalar.text = str(reussG)
shearModReuss.append(shearModReussScalar)
shearModHillScalar = etree.Element("scalar")
shearModHillScalar.attrib["dataType"] = "xsd:double"
shearModHillScalar.attrib["units"] = "castepunits:"+ units.lower()
shearModHillScalar.text = str((voigtG+reussG)/2)
shearModHill.append(shearModHillScalar)
if(options.debug):
print etree.tostring(startnode,pretty_print=True)
else:
# wrap it in an ElementTree instance, and save as XML
tree.write(basefile,pretty_print=True)
return
import sys
import mcta
import mcta_vis
import mcta_rw
import scipy as sp
# options
verbose = False
showfigs = False
figs2png = False
savememdump = False
# global variables
base = None
sp.set_printoptions(suppress=True,precision=3,linewidth=140)
### Data processing ######################################################################
def ProcessCLI():
"""Process CLI parameters"""
global base
global verbose
global showfigs
global figs2png
global savememdump
if len(sys.argv) == 1:
print("Missing argument\n\nSyntax:\n\tipython mcta_cli.py -- [options] {BaseName}")
print(HELP_MSG)
sys.exit(0)
# -*- coding: utf-8 -*-
import npfs as npfs
import scipy as sp
from sklearn.cross_validation import train_test_split, StratifiedKFold
from sklearn.grid_search import GridSearchCV
from sklearn.svm import SVC
from sklearn import preprocessing
import time
import pickle
sp.set_printoptions(precision=3)
data_name = 'aisa'
data = sp.load('Data/' + data_name + '.npz')
X = data['X']
y = data['Y']
C = len(sp.unique(y))
print "Nb of samples: ", X.shape[0], " Nb of features: ", X.shape[
1], "Nb of classes: ", C, "\n"
ntrial = 20
Nts = [(50, False), (100, False), (200, False), (0.005, True), (0.01, True),
(0.025, True)] # Nb of samples per class in training set
param_grid_gmm = [0.01, 0.1, 1, 10, 100, 1000, 10000, 100000, 1000000]
svmTest = True
param_grid_svm = [
{
'C': [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000],
import cPickle as pickle
import csv
import re
import scipy
import pylab
__author__ = 'marrabld'
import pidly # Use this to call one of DIMITRI's IDL functions and pass back the data structure
##!! This is required to prevent unwanted linefeeds in the csv file
scipy.set_printoptions(linewidth=2000)
class DimitriSatelliteObject():
def __init__(self, gdl_path='/usr/bin/gdl'):
self.idl = pidly.IDL(gdl_path, idl_prompt='GDL> ')
self.l1b_data = None
self.bands = {
'PARASOL': [
'443', '490p', '490u', '490q', '565', '670p', '670u', '670q',
'763', '765', '865p', '865u', '865q', '910', '1020'
],
'MERIS': [
'412', '443', '490', '510', '560', '620', '665', '681', '708',
'753', '761', '778', '865', '885', '900'
]
} ## !!! these are the same as DIMITRI FOR NOW!! CHECK
self.sensor_name = 'PARASOL'
import matplotlib.pyplot as plt
import networkx as nx
import sys
import scipy as sp
from networkx.generators.expanders import *
import itertools
n=int(input("enter n value")) #size of the graph or number of nodes in the graph
i=int(input("enter i value")) #To choose type of the graph
if i == 1:
G = nx.cycle_graph(n)#creates cycle graph of n nodes
print(nx.info(G))
A = nx.adjacency_matrix(G)
sp.set_printoptions(linewidth=sp.inf)
sp.set_printoptions(threshold=sys.maxsize)
print(A.todense(),file=open("cycle_graph\%d.txt"%(n),'w')) #Outputs the adjacency matrix to a textfile and stores it in a folder called 'cycle graph'
nx.draw(G)
plt.show()
elif i == 2:
G = nx.wheel_graph(n) #creates wheel graph of n nodes
print(nx.info(G))
A = nx.adjacency_matrix(G) #creates an adjacency matrix for graph G
sp.set_printoptions(linewidth=sp.inf)
sp.set_printoptions(threshold=sys.maxsize)
print(A.todense(),file=open("wheel_graph\%d.txt"%(n),'w')) #Outputs the adjacency matrix to a textfile and stores it in a folder called 'wheel graph'
nx.draw(G)
plt.show()
elif i == 3:
k=int(input("enter k value")) %Clique size
G = nx.windmill_graph(n,k) #creates wheel graph of n nodes
from itertools import (product)
# Imports from OpenCV
try:
from cv2 import (filter2D)
from cv2.cv import (GetSubRect, NamedWindow, GetCaptureProperty)
from cv2.cv import (CaptureFromCAM, CreateMat, GetMat)
from cv2.cv import (QueryFrame, ShowImage)
from cv2.cv import (WaitKey, DestroyAllWindows, CV_8UC3)
from cv2.cv import (CV_CAP_PROP_FRAME_WIDTH, CV_CAP_PROP_FRAME_HEIGHT)
except ImportError:
print("Module OpenCV (cv2) is required")
#SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
# Change how scipy displays numbers.
set_printoptions(precision=2)
class Control(object):
def __init__(self, name, limits, factor=1.1):
assert isinstance(limits, tuple) or isinstance(limits, list)
self.limit = list(limits)
assert len(self.limit) == 3
assert self.limit[0] <= self.limit[1] <= self.limit[2]
assert self.limit[0] > 0.0
self.factor = factor
self.name = name
self.todo = True
def increment(self):
self.todo = (self.limit[1] < self.limit[2])
"""
Created May 30, 2012
Author: Spencer Lyon
"""
import numpy as np
import scipy as sp
import scipy.sparse.linalg as spla
import scipy.linalg as la
import matplotlib.pyplot as plt
import pylab
import Bandpass_Filter as bpf
import hp_filter as hpf
sp.set_printoptions(linewidth=140, suppress = True, precision = 5)
def problem_1():
"""
This function uses the file GPDIC96.txt as the data for this problem.
It produces the T, cycle sets and plots what Ben asked for in 1.d.
"""
data = sp.loadtxt('GPDIC96.txt', skiprows=1, dtype=float,
converters={0:pylab.datestr2num})
yData = data[:,1]
T, c = hpf.hp_filter(yData)
time = sp.linspace(0, T.size, T.size)
plt.plot(time, yData)
plt.plot(time, T)
plt.figure()
plt.plot(time, c)
j = nodes.index(nj)
guidance_matrix[i, j] = 1.0
guidance_matrix = sparse.lil_matrix(guidance_matrix)
# pos = sum(x > 0 for x in guidance_matrix)
print(guidance_matrix)
ward = Ward(n_clusters=6, n_components=2, connectivity=guidance_matrix)
predicts = ward.fit_predict(self.A)
print(predicts)
# print(circles.keys(), len(circles.itervalues())
if __name__ == "__main__":
sp.set_printoptions(precision=2, suppress=True)
nodes = [1, 2, 3, 4, 5, 6]
edges = [[1, 2], [1, 3], [2, 3], [3, 4], [4, 5], [4, 6], [5, 6]]
Q1 = sp.asmatrix(sp.identity(6))
Q = sp.mat([[1.0, 1.0, 1.0, 1.0, -1.0, -1.0],
[1.0, 1.0, 1.0, 1.0, -1.0, -1.0],
[1.0, 1.0, 1.0, 1.0, -1.0, -1.0],
[1.0, 1.0, 1.0, 1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, 1.0, 1.0],
[-1.0, -1.0, -1.0, -1.0, 1.0, 1.0]])
c = Cluster(nodes, edges)
vec = c.spectral(2)
print(vec)
# -*- coding: utf-8 -*-
import npfs as npfs
import scipy as sp
from sklearn.cross_validation import train_test_split, StratifiedKFold
import time
import pickle
sp.set_printoptions(precision=10)
data_name = 'aisa'
data = sp.load('Data/'+data_name+'.npz')
X = data['X']
y = data['Y']
C = len(sp.unique(y))
print "Nb of samples: ",X.shape[0]," Nb of features: ",X.shape[1],"Nb of classes: ",C,"\n"
ntrial = 20
minVar = 2
maxVar = 25
Nts = [(50,False), (100,False), (200,False), (0.005,True), (0.01,True), (0.025,True)] # Nb of samples per class in training set
methods = ['SFFS']#['forward','SFFS']
criterions = ['accuracy', 'kappa', 'F1Mean','JM', 'divKL']
for Nt,stratification in Nts:
for criterion in criterions:
for method in methods:
if stratification:
filename = data_name+'_'+method+'_spls_'+str(Nt)+'_stratified_trials_'+str(ntrial)+'_'+criterion
__email__ = "*****@*****.**"
__contact__ = "*****@*****.**"
__status__ = "Demonstration"
__date__ = "20111110"
###############################################################################
from scipy import array, sqrt, arange, rot90, fabs, where, around
from scipy import set_printoptions
from itertools import product
from optparse import OptionParser
from subprocess import call
import pylab as p
#import mpl_toolkits.mplot3d.axes3d as p3
set_printoptions(precision=2, linewidth=500)
class Paraboloid(object):
def __init__(self, **kw):
self.kw = kw
self.E = kw.get('E', 12.0) # Edge halflength of the containing cube.
self.dE = kw.get('dE', 0.2) # Edge increment length.
self.dR = kw.get('dR', 0.1) # Radial increment for coincidence.
#print self.E, self.dE, self.dR
rng = list(arange(-self.E,self.E+self.dE, self.dE)) # Edge values.
# Force rebalance
rng -= (rng[-1] + rng[0])/2.0
self.X = array([rng,] * len(rng)) # x values plane segment
self.Y = rot90(self.X) # y values plane segment
self.r = sqrt(self.X**2 + self.Y**2) # r values plane segment
#print self.kw
#mmc with different values for service rates
from scipy import mean, digitize, cumsum, array, concatenate, set_printoptions, nonzero, insert, ones, random
from scipy.stats import uniform, expon
import numpy as np
from QueueingTheory import mm1, getRandomArrivalServiceTimes
def prints(s):
print s
return s
set_printoptions(precision = 7)
set_printoptions(suppress=True)
arrival_rate = 1
service_rate = 1/6.0 * ones(3) #array([1.09, 2.000005, 1])
server_prob = array([0.25, 0.25, 0.5])
n_server = server_prob.size
n_process = 100
time_interval = 10
initial_state = (7,2,3)
arrival_times = getRandomArrivalServiceTimes(n_process, arrival_rate, None)[0]
sum_initial_state = sum(initial_state)
# preparing initial state for each mm1 simulation
initial_states = zip(initial_state, [arrival_times[sum_initial_state]] * len(initial_state))
# maps kth process to ith server
server_address_table_forced = random.permutation(concatenate([ones(state) * i for i,state in enumerate(initial_state)]))
print "forced server address table", server_address_table_forced
server_address_table = concatenate([server_address_table_forced, digitize(uniform.rvs(size = n_process-sum_initial_state), cumsum(server_prob))])
last_sub = tconv(subs, -1)[1]
print(last_sub)
print(subs[-1])
pb_array = sp.zeros((int(last_sub), 3))
count = sp.arange(int(last_sub))
pb_array[:, 0] = count[:] # an index for each sample starting at 0
pb_array[:,
1] = pb_array[:,
0] * 0.01 #0.01 is the size of the MFCC windows used in play.py, this is the starting point for each window
#print(pb_array)
#print(tconv(subs,1))
#print(len(subs))
sp.set_printoptions(threshold=sp.nan)
#print(subs)
#print(pb_array)
i = 0
j = 0 # i is counter over subs array, j is counter over sample array (stored in pb_array)
while True:
if i + 1 > len(
pb_array
) - 1: #matrices are indexed from 0 but the length returns the 'normal' length i.e len([1]) returns 1 not 0
print('substimes length exceeded')
print(i)
break
if j > len(subs) - 1:
print('pb array length exceeded')
print(j)
[1] Xiangnan He, Min-Yen Kan, Peichu Xie, and Xiao Chen. 2014. Comment-based multi-view clustering of web 2.0 items. In Proceedings of the 23rd international conference on World wide web (WWW '14). @author: HeXiangnan ([email protected]) ''' import scipy as sp import numpy as np import scipy.sparse as sparse import data_load as dl import metrics from operator import div from utils import dot, multiply, elop, initialize_random, labels_to_matrix from kmeans import kmeans np.set_printoptions(threshold='nan') sp.set_printoptions(threshold='nan') def conmf(datas, cluster_size, weights, regu_weights, norm="l2", seed="k-means", post="direct", method="pair-wise", gt=None): """ CoNMF on multi-view dataset (represented as datas). :param datas (type: list<csr_matrix>). [data_k]
# -*- coding: utf-8 -*- import scipy as sci import scipy.linalg as linalg from mpi4py import MPI import matplotlib.pyplot as plt import matplotlib.animation as animation import pylab as py import sys sci.set_printoptions(linewidth =1000) sci.set_printoptions(threshold=50000) py.rcParams['figure.figsize'] = 12, 12 ''' ln = lambda neumann ld = lambda dirichlet ldo = lambda dirichlet old ''' rank = MPI.COMM_WORLD.rank N = 20 Tn = 15. Tw = 5. Th = 40. T0 = -20 w = 0.5 NbrItr = 20 def setAb(r,k,m,n):
#------------------------------------------------------------
import time
import numpy as np
import scipy as sp
import matplotlib
matplotlib.use('Agg') # needed for using matplotlib on remote machine
import matplotlib.pyplot as plt
#------------------------------------------------------------
import gen_data
import ipm_func
import svm_func
import load_real_data
from parameters import m, w, n, p, gamma, sigma_step, sigma, tol_cg, MAXIT_cg, DENSITY, power
#------------------------------------------------------------
np.random.seed(0) # reset random seed
sp.set_printoptions(precision=4, suppress=True)
np.set_printoptions(precision=4)
#------------------------------------------------------------
# Sketched IPM vs Standard IPM, 1 Run, number of iterations, condition number
#------------------------------------------------------------
directory = '/Users/grego/GitProjects/SketchIPM_python/ipm_figures'
#------------------------------------------------------------
if __name__ == '__main__':
print('---------------------------', '\n')
print('Test IPM SVM real or synthetic dataset, 1 Run', '\n')
#------------------------------------------------------------
#------------------------------------------------------------
# Data LOAD
When a sensor changes state, it generates a difference signal.
"""
###############################################################################
import os, inspect, scipy, random
from optparse import OptionParser
from scipy import arange, exp, random, zeros, ones, array
from scipy.constants import *
###############################################################################
scipy.set_printoptions(precision=2, linewidth=1000)
#CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
class Spectrum(object):
# First instance forces initialization, wait for OptionParser to parse argv.
initialized = False
stepsize = None
visible = None
wavelengths = None
energy = None
length = None
named = {}
rand = 0
def id(this, name=None):
from __future__ import division, print_function, absolute_import
from scipy import array, arange, ones, sort, cos, pi, rand, \
set_printoptions, r_
from scipy.sparse.linalg import lobpcg
from scipy import sparse
from pylab import loglog, show, xlabel, ylabel, title
set_printoptions(precision=8,linewidth=90)
import time
def sakurai(n):
""" Example taken from
T. Sakurai, H. Tadano, Y. Inadomi and U. Nagashima
A moment-based method for large-scale generalized eigenvalue problems
Appl. Num. Anal. Comp. Math. Vol. 1 No. 2 (2004) """
A = sparse.eye(n, n)
d0 = array(r_[5,6*ones(n-2),5])
d1 = -4*ones(n)
d2 = ones(n)
B = sparse.spdiags([d2,d1,d0,d1,d2],[-2,-1,0,1,2],n,n)
k = arange(1,n+1)
w_ex = sort(1./(16.*pow(cos(0.5*k*pi/(n+1)),4))) # exact eigenvalues
return A,B, w_ex
m = 3 # Blocksize
#
import networkx as nx
import matplotlib.pyplot as plt
import sklearn
import trilearn.graph.trajectory as mc
import trilearn.graph.graph as glib
import trilearn.graph.decomposable as dlib
import trilearn.graph.junction_tree as jtlib
import trilearn.graph.empirical_graph_distribution as gdist
import trilearn.pgibbs
import trilearn.smc as smc
from trilearn.distributions import multivariate_students_t as tdist
from trilearn.distributions import sequential_junction_tree_distributions as seqjtdist
scipy.set_printoptions(precision=2, suppress=True)
class GraphPredictive(sklearn.base.BaseEstimator):
def __init__(self,
n_particles=None,
n_pgibbs_samples=None,
prompt_burnin=False,
only_map_graph=False,
standard_bayes=False,
cta_alpha=0.5,
cta_beta=0.5,
true_graphs=None,
async=False):
self.n_particles = n_particles
self.n_pgibbs_samples = n_pgibbs_samples
