def getkgrid(ng=128,boxsize=512.,whattoget = 'k'):
thirdim=ng/2+1
sk = (ng,ng,thirdim)
kx = N.fromfunction(lambda x,y,z:x, sk).astype(N.float32)
kx[N.where(kx > ng/2)] -= ng
kz = N.fromfunction(lambda x,y,z:z, sk).astype(N.float32)
kz[N.where(kz > ng/2)] -= ng
if whattoget != 'kxkzk2':
kmin = 2.*N.pi/boxsize
kx *= kmin
kz *= kmin
k2 = kx**2+kx.swapaxes(0,1)**2+kz**2
if whattoget == 'kxkzOk2':
k2[0,0,0] = 1.
return kx/k2, kz/k2
elif whattoget == 'kxkzk2':
k2[0,0,0]= 1.
return kx, kz, k2
elif whattoget == 'k2':
return k2
elif whattoget == 'k':
return N.sqrt(k2)
else:
print 'I dunno what to get'
def _clusterKMeans(image, K, numIterations, debug=None):
width, height = image.shape[:2]
## add an extra channel containing distance from center to make
## clusters favor circular features around the center of the image
# if we have a 2 pixel wide image, the center should be between pixels 0 and 1
center_x, center_y = (width-1)/2., (height-1)/2.
# compute distance from center
dx = np.fromfunction(lambda x,y: x - center_x, (width,1))
dy = np.fromfunction(lambda x,y: y - center_y, (1,height))
dist_from_center = np.sqrt(np.add(np.square(dx), np.square(dy)))
dist_from_center /= dist_from_center[0,0] * COORDINATE_TO_COLOR_RATIO
# add as a new channel to image
image = np.dstack([image, dist_from_center])
# sample 10000 pixels and use K-means to determine the clusters
channels = image.shape[2]
pixels = image.reshape(-1, channels)
npoints = pixels.shape[0]
indices = np.random.choice(npoints, 10000)
samples = pixels[indices]
centroids, _ = kmeans(samples, K, numIterations)
quantized, _ = vq(pixels, centroids)
clustered = quantized.reshape(width, height)
if debug is not None:
debug["clustered"] = labnorm2rgb(centroids[clustered])
return centroids, clustered
def detectorgeometry(ddef, npdtype='float32'):
""" calculates the geometric properties of the detector
from its definitions
parameters:
ddef is array detector definitions
returns:
pixelpositions The endpoint of all the vectors
unitnormalvector of the detector """
c0 = np.array([ddef[0],ddef[1],ddef[2]]) # corner c1-c0-c2
c1 = np.array([ddef[3],ddef[4],ddef[5]]) # corner c0-c1-c3 or 1st axis endposition
c2 = np.array([ddef[6],ddef[7],ddef[8]]) # corner c0-c2-c3 or 2nd axis endposition
r1 = ddef[9] # resolution in 1st dimension
r2 = ddef[10] # resolution in 2nd dimension
dshape = (r2,r1) # CONTROL of SEQUENCE
# unit direction vectors of detector sides
di = (c1 - c0) * (1.0/r1)
dj = (c2 - c0) * (1.0/r2)
def pcfun(j,i,k): return c0[k] + (i+0.5) * di[k] + (j+0.5) * dj[k]
def pcfunx(j,i): return pcfun(j,i,0)
def pcfuny(j,i): return pcfun(j,i,1)
def pcfunz(j,i): return pcfun(j,i,2)
pxs = numpy.fromfunction(pcfunx, shape=dshape, dtype=npdtype )
pys = numpy.fromfunction(pcfuny, shape=dshape, dtype=npdtype )
pzs = numpy.fromfunction(pcfunz, shape=dshape, dtype=npdtype )
pixelpositions = np.array(numpy.dstack((pxs,pys,pzs))) # shape = (r2,r1,3)
pixelareavector = np.array(numpy.cross(di, dj))
result = np.zeros(dshape)
return pixelpositions, pixelareavector, dshape, result
def test_masked_full_multi(self):
data = numpy.ones((50, 10))
data[:, 5:] = 2
mask1 = numpy.ones((50, 10))
mask1[:, :5] = 0
mask2 = numpy.ones((50, 10))
mask2[:, 5:] = 0
mask3 = numpy.ones((50, 10))
mask3[:25, :] = 0
data_multi = numpy.column_stack(
(data.ravel(), data.ravel(), data.ravel()))
mask_multi = numpy.column_stack(
(mask1.ravel(), mask2.ravel(), mask3.ravel()))
masked_data = numpy.ma.array(data_multi, mask=mask_multi)
lons = numpy.fromfunction(lambda y, x: 3 + x, (50, 10))
lats = numpy.fromfunction(lambda y, x: 75 - y, (50, 10))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
res = kd_tree.resample_nearest(swath_def,
masked_data, self.area_def, 50000,
fill_value=None, segments=1)
expected_fill_mask = numpy.fromfile(os.path.join(os.path.dirname(__file__),
'test_files',
'mask_test_full_fill_multi.dat'),
sep=' ').reshape((800, 800, 3))
fill_mask = res.mask
cross_sum = res.sum()
expected = 357140.0
self.assertAlmostEqual(cross_sum, expected,
msg='Failed to resample masked data')
self.assertTrue(numpy.array_equal(fill_mask, expected_fill_mask),
msg='Failed to create fill mask on masked data')
def test_masked_multi_from_sample(self):
data = numpy.ones((50, 10))
data[:, 5:] = 2
mask1 = numpy.ones((50, 10))
mask1[:, :5] = 0
mask2 = numpy.ones((50, 10))
mask2[:, 5:] = 0
mask3 = numpy.ones((50, 10))
mask3[:25, :] = 0
data_multi = numpy.column_stack(
(data.ravel(), data.ravel(), data.ravel()))
mask_multi = numpy.column_stack(
(mask1.ravel(), mask2.ravel(), mask3.ravel()))
masked_data = numpy.ma.array(data_multi, mask=mask_multi)
lons = numpy.fromfunction(lambda y, x: 3 + x, (50, 10))
lats = numpy.fromfunction(lambda y, x: 75 - y, (50, 10))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
valid_input_index, valid_output_index, index_array, distance_array = \
kd_tree.get_neighbour_info(swath_def,
self.area_def,
50000, neighbours=1, segments=1)
res = kd_tree.get_sample_from_neighbour_info('nn', (800, 800),
masked_data,
valid_input_index,
valid_output_index, index_array,
fill_value=None)
expected_fill_mask = numpy.fromfile(os.path.join(os.path.dirname(__file__),
'test_files',
'mask_test_full_fill_multi.dat'),
sep=' ').reshape((800, 800, 3))
fill_mask = res.mask
self.assertTrue(numpy.array_equal(fill_mask, expected_fill_mask),
msg='Failed to create fill mask on masked data')
def test_custom_multi(self):
def wf1(dist):
return 1 - dist / 100000.0
def wf2(dist):
return 1
def wf3(dist):
return numpy.cos(dist) ** 2
data = numpy.fromfunction(lambda y, x: (y + x) * 10 ** -6, (5000, 100))
lons = numpy.fromfunction(
lambda y, x: 3 + (10.0 / 100) * x, (5000, 100))
lats = numpy.fromfunction(
lambda y, x: 75 - (50.0 / 5000) * y, (5000, 100))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
data_multi = numpy.column_stack((data.ravel(), data.ravel(),
data.ravel()))
if (sys.version_info < (2, 6) or
(sys.version_info >= (3, 0) and sys.version_info < (3, 4))):
res = kd_tree.resample_custom(swath_def, data_multi,
self.area_def, 50000, [wf1, wf2, wf3], segments=1)
else:
with warnings.catch_warnings(record=True) as w:
res = kd_tree.resample_custom(swath_def, data_multi,
self.area_def, 50000, [wf1, wf2, wf3], segments=1)
self.assertFalse(
len(w) != 1, 'Failed to create neighbour radius warning')
self.assertFalse(('Possible more' not in str(
w[0].message)), 'Failed to create correct neighbour radius warning')
cross_sum = res.sum()
expected = 1461.842980746
self.assertAlmostEqual(cross_sum, expected,
msg='Swath multi channel custom resampling failed')
def test_masked_gauss(self):
data = numpy.ones((50, 10))
data[:, 5:] = 2
lons = numpy.fromfunction(lambda y, x: 3 + x, (50, 10))
lats = numpy.fromfunction(lambda y, x: 75 - y, (50, 10))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
mask = numpy.ones((50, 10))
mask[:, :5] = 0
masked_data = numpy.ma.array(data, mask=mask)
res = kd_tree.resample_gauss(swath_def, masked_data.ravel(),
self.area_def, 50000, 25000, segments=1)
expected_mask = numpy.fromfile(os.path.join(os.path.dirname(__file__),
'test_files',
'mask_test_mask.dat'),
sep=' ').reshape((800, 800))
expected_data = numpy.fromfile(os.path.join(os.path.dirname(__file__),
'test_files',
'mask_test_data.dat'),
sep=' ').reshape((800, 800))
expected = expected_data.sum()
cross_sum = res.data.sum()
self.assertTrue(numpy.array_equal(expected_mask, res.mask),
msg='Gauss resampling of swath mask failed')
self.assertAlmostEqual(cross_sum, expected, places=3,
msg='Gauss resampling of swath masked data failed')
def test_gauss_multi_mp_segments(self):
data = numpy.fromfunction(lambda y, x: (y + x) * 10 ** -6, (5000, 100))
lons = numpy.fromfunction(
lambda y, x: 3 + (10.0 / 100) * x, (5000, 100))
lats = numpy.fromfunction(
lambda y, x: 75 - (50.0 / 5000) * y, (5000, 100))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
data_multi = numpy.column_stack((data.ravel(), data.ravel(),
data.ravel()))
if (sys.version_info < (2, 6) or
(sys.version_info >= (3, 0) and sys.version_info < (3, 4))):
res = kd_tree.resample_gauss(swath_def, data_multi,
self.area_def, 50000, [
25000, 15000, 10000],
nprocs=2, segments=1)
else:
with warnings.catch_warnings(record=True) as w:
res = kd_tree.resample_gauss(swath_def, data_multi,
self.area_def, 50000, [
25000, 15000, 10000],
nprocs=2, segments=1)
self.assertFalse(
len(w) != 1, 'Failed to create neighbour radius warning')
self.assertFalse(('Possible more' not in str(
w[0].message)), 'Failed to create correct neighbour radius warning')
cross_sum = res.sum()
expected = 1461.84313918
self.assertAlmostEqual(cross_sum, expected,
msg='Swath multi channel segments resampling gauss failed')
def test_custom(self):
def wf(dist):
return 1 - dist / 100000.0
data = numpy.fromfunction(lambda y, x: (y + x) * 10 ** -5, (5000, 100))
lons = numpy.fromfunction(
lambda y, x: 3 + (10.0 / 100) * x, (5000, 100))
lats = numpy.fromfunction(
lambda y, x: 75 - (50.0 / 5000) * y, (5000, 100))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
if (sys.version_info < (2, 6) or
(sys.version_info >= (3, 0) and sys.version_info < (3, 4))):
res = kd_tree.resample_custom(swath_def, data.ravel(),
self.area_def, 50000, wf, segments=1)
else:
with warnings.catch_warnings(record=True) as w:
res = kd_tree.resample_custom(swath_def, data.ravel(),
self.area_def, 50000, wf, segments=1)
self.assertFalse(
len(w) != 1, 'Failed to create neighbour radius warning')
self.assertFalse(('Possible more' not in str(
w[0].message)), 'Failed to create correct neighbour radius warning')
cross_sum = res.sum()
expected = 4872.81050729
self.assertAlmostEqual(cross_sum, expected,
msg='Swath custom resampling failed')
def create(synFile, datFile, outDir):
if not os.path.exists(outDir):
os.makedirs(outDir)
syn = Seismogram(synFile)
dat = Seismogram(datFile)
# Read
syn.readHeader()
dat.readHeader()
syn.readData()
dat.readData()
xDat, yDat = dat.reverse()
xSyn, ySyn = syn.reverse()
xDat = cosine_taper(xDat, 0.10)
yDat = cosine_taper(yDat, 0.10)
xSyn = cosine_taper(xSyn, 0.10)
ySyn = cosine_taper(ySyn, 0.10)
xRes = xSyn - xDat
yRes = ySyn - yDat
xRes = np.fromfunction(lambda i: xRes[i] if abs(xRes[i]).any() > 1e-100 else 0,
(xRes.shape), dtype=int)
yRes = np.fromfunction(lambda i: yRes[i] if abs(yRes[i]).any() > 1e-100 else 0,
(yRes.shape), dtype=int)
syn.writeAdjointSource(xRes, yRes, outDir)
def ListPlanes_Cubic(self,latticeConstant,k):
"""
According to the apparatus geometry, make a list of avaible
reflection planes.
"""
#wave length
lamb = 2*pi/k
maxtheta = arctan(self.L/sqrt(2)/self.D)/2
#Bragg's law
d = latticeConstant
nmax = int(2*d*sin(maxtheta)/lamb)
assert nmax>0
N = nmax*2+1
nsize = [N, N, N]
h = fromfunction(lambda a,b,c: (a-nmax), nsize).astype(int)
k = fromfunction(lambda a,b,c: (b-nmax), nsize).astype(int)
l = fromfunction(lambda a,b,c: (c-nmax), nsize).astype(int)
#Interplanar spacing calculated
ds = d/sqrt(h**2+k**2+l**2)
hkl = {}
thetas = arcsin(lamb/2/ds)
#Check for allowed hkls and put in a list
for i in range(N):
def load_cifar(self,data_path):
image_list = []
label_list = []
for i in xrange(5):
fo = open(os.path.join(data_path,'data_batch_'+str(i+1)),'rb')
dict = cPickle.load(fo)
fo.close()
image_list.append(dict['data'])
label_list.append(dict['labels'])
train_images = np.r_[image_list[0],image_list[1],image_list[2],image_list[3],image_list[4]]
train_labels = np.r_[label_list[0],label_list[1],label_list[2],label_list[3],label_list[4]]
fo = open(os.path.join(data_path,'test_batch'), 'rb')
dict= cPickle.load(fo)
fo.close()
test_images = dict['data']
test_labels = dict['labels']
test_images = test_images / 255.0
train_images = train_images / 255.0
# resize images to 2D
dsize = 32
train_images = train_images.reshape(len(train_images),3,dsize,dsize)
test_images = test_images.reshape(len(test_images),3,dsize,dsize)
train_labels = np.array(train_labels)
test_labels = np.array(test_labels)
self.test_images = test_images
self.test_labels = np.fromfunction(lambda i,j:j==test_labels[i],(len(test_labels),max(test_labels)+1),dtype=int)+0
self.train_images = train_images
self.train_labels = np.fromfunction(lambda i,j:j==train_labels[i],(len(train_labels),max(train_labels)+1),dtype=int)+0
def __init__(self, angle, col, dangle=5, parent=None):
super().__init__(parent)
color = QColor(0, 0, 0) if col else QColor(128, 128, 128)
angle_d = np.rad2deg(angle)
angle_2 = 90 - angle_d - dangle
angle_1 = 270 - angle_d + dangle
dangle = np.deg2rad(dangle)
arrow1 = pg.ArrowItem(
parent=self, angle=angle_1, brush=color, pen=pg.mkPen(color)
)
arrow1.setPos(np.cos(angle - dangle), np.sin(angle - dangle))
arrow2 = pg.ArrowItem(
parent=self, angle=angle_2, brush=color, pen=pg.mkPen(color)
)
arrow2.setPos(np.cos(angle + dangle), np.sin(angle + dangle))
arc_x = np.fromfunction(
lambda i: np.cos((angle - dangle) + (2 * dangle) * i / 120.),
(121,), dtype=int
)
arc_y = np.fromfunction(
lambda i: np.sin((angle - dangle) + (2 * dangle) * i / 120.),
(121,), dtype=int
)
pg.PlotCurveItem(
parent=self, x=arc_x, y=arc_y, pen=pg.mkPen(color), antialias=False
)
def multi_2_func():
"""
使用函数创建2维数组
:return:
"""
print np.fromfunction(lambda x, y: (x + 1) * y, (10, 5))
split_line()
def test_gauss_multi_uncert(self):
data = numpy.fromfunction(lambda y, x: (y + x)*10**-6, (5000, 100))
lons = numpy.fromfunction(lambda y, x: 3 + (10.0/100)*x, (5000, 100))
lats = numpy.fromfunction(lambda y, x: 75 - (50.0/5000)*y, (5000, 100))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
data_multi = numpy.column_stack((data.ravel(), data.ravel(),\
data.ravel()))
if sys.version_info < (2, 6):
res, stddev, counts = kd_tree.resample_gauss(swath_def, data_multi,\
self.area_def, 50000, [25000, 15000, 10000],
segments=1, with_uncert=True)
else:
with warnings.catch_warnings(record=True) as w:
res, stddev, counts = kd_tree.resample_gauss(swath_def, data_multi,\
self.area_def, 50000, [25000, 15000, 10000],
segments=1, with_uncert=True)
self.failIf(len(w) != 1, 'Failed to create neighbour radius warning')
self.failIf(('Possible more' not in str(w[0].message)), 'Failed to create correct neighbour radius warning')
cross_sum = res.sum()
cross_sum_stddev = stddev.sum()
cross_sum_counts = counts.sum()
expected = 1461.84313918
expected_stddev = 0.446204424799
expected_counts = 4934802.0
self.assertTrue(res.shape == stddev.shape and stddev.shape == counts.shape and counts.shape == (800, 800, 3))
self.assertAlmostEqual(cross_sum, expected,
msg='Swath multi channel resampling gauss failed on data')
self.assertAlmostEqual(cross_sum_stddev, expected_stddev,
msg='Swath multi channel resampling gauss failed on stddev')
self.assertAlmostEqual(cross_sum_counts, expected_counts,
msg='Swath multi channel resampling gauss failed on counts')
def test_false_color():
N = 100
M = 100
part = np.zeros((N,M))
part[:N/2, :M/2] = 0
part[N/2:, :M/2] = 1
part[:N/2, M/2:] = 2
part[N/2:, M/2:] = 3
img = np.zeros((N,M,3))
img[..., 0] = np.fromfunction(lambda i, j: i+j+0, (N,M))
img[..., 1] = np.fromfunction(lambda i, j: i+j+1, (N,M))
img[..., 2] = np.fromfunction(lambda i, j: i+j+2, (N,M))
mean_color = partition_mean_color(img, part)
colors = np.zeros((3,4))
colors[:, 0] = np.array([49, 50, 51])
colors[:, 1] = np.array([99, 100, 101])
colors[:, 2] = np.array([99, 100, 101])
colors[:, 3] = np.array([149, 150, 151])
for i in range(4):
coords = np.where(part == i)
for ch in range(3):
assert_equal(len(np.unique(mean_color[coords[0], coords[1], ch])), 1)
assert_equal(mean_color[coords[0][0], coords[1][0], ch], colors[ch, i])
def __set_pm__(L, window, taps, fwidth):
global pm
if pm['L'] == L and pm['taps'] == taps and \
pm['fwidth'] == fwidth:
if type(window) == str and pm['window_name'] == window: return
elif window is pm['window']: return
else:
pm['L'] = L
pm['taps'] = taps
pm['fwidth'] = fwidth
def sinx_x(x):
t = n.pi * taps * fwidth * (x/float(L) - .5)
v = n.where(t != 0, t, 1)
return n.where(t != 0, n.sin(v) / v, 1)
pm['sinx_x'] = n.fromfunction(sinx_x, (L,))
if type(window) == str:
wf = {}
wf['blackman'] = lambda x: .42-.5*n.cos(2*n.pi*x/(L-1))+.08*n.cos(4*n.pi*x/(L-1))
wf['blackman-harris'] = lambda x: .35875 - .48829*n.cos(2*n.pi*x/(L-1)) + .14128*n.cos(4*n.pi*x/(L-1)) - .01168*n.cos(6*n.pi*x/(L-1))
wf['gaussian0.4'] = lambda x: n.exp(-0.5 * ((x - (L-1)/2)/(0.4 * (L-1)/2))**2)
wf['kaiser2'] = lambda x: i0(n.pi * 2 * n.sqrt(1-(2*x/(L-1) - 1)**2)) / i0(n.pi * 2)
wf['kaiser3'] = lambda x: i0(n.pi * 3 * n.sqrt(1-(2*x/(L-1) - 1)**2)) / i0(n.pi * 3)
wf['hamming'] = lambda x: .54 - .46 * n.cos(2*n.pi*x/(L-1))
wf['hanning'] = lambda x: .5 - .5 * n.cos(2*n.pi*x/(L-1))
wf['parzen'] = lambda x: 1 - n.abs(L/2. - x) / (L/2.)
wf['none'] = lambda x: 1
pm['window'] = n.fromfunction(wf[window], (L,))
pm['window_name'] = window
else:
pm['window'] = window
pm['window_name'] = None
pm['window_sinx_x'] = pm['window'] * pm['sinx_x']
def generate_nearest_neighbour_linesample_arrays(source_area_def, target_area_def,
radius_of_influence, nprocs=1):
"""Generate linesample arrays for nearest neighbour grid resampling
Parameters
-----------
source_area_def : object
Source area definition as AreaDefinition object
target_area_def : object
Target area definition as AreaDefinition object
radius_of_influence : float
Cut off distance in meters
nprocs : int, optional
Number of processor cores to be used
Returns
-------
(row_indices, col_indices) : tuple of numpy arrays
"""
if not (isinstance(source_area_def, pr.geometry.AreaDefinition) and
isinstance(target_area_def, pr.geometry.AreaDefinition)):
raise TypeError('source_area_def and target_area_def must be of type '
'geometry.AreaDefinition')
valid_input_index, valid_output_index, index_array, distance_array = \
pr.kd_tree.get_neighbour_info(source_area_def,
target_area_def,
radius_of_influence,
neighbours=1,
nprocs=nprocs)
# Enumerate rows and cols
rows = np.fromfunction(lambda i, j: i, source_area_def.shape,
dtype=np.int32).ravel()
cols = np.fromfunction(lambda i, j: j, source_area_def.shape,
dtype=np.int32).ravel()
# Reduce to match resampling data set
rows_valid = rows[valid_input_index]
cols_valid = cols[valid_input_index]
# Get result using array indexing
number_of_valid_points = valid_input_index.sum()
index_mask = (index_array == number_of_valid_points)
index_array[index_mask] = 0
row_sample = rows_valid[index_array]
col_sample = cols_valid[index_array]
row_sample[index_mask] = -1
col_sample[index_mask] = -1
# Reshape to correct shape
row_indices = row_sample.reshape(target_area_def.shape)
col_indices = col_sample.reshape(target_area_def.shape)
row_indices = _downcast_index_array(row_indices,
source_area_def.shape[0])
col_indices = _downcast_index_array(col_indices,
source_area_def.shape[1])
return row_indices, col_indices
def register_reproject_with_errors(inputImages, outputImages, intErrorImages, outputErrorImages, refImage, processDir, headerName="header.hdr"):
cmds.mGetHdr(refImage,headerName)
mw.reproject(inputImages,outputImages,header=headerName,north_aligned=True,system='EQUJ',exact_size=True,common=True,silent_cleanup=True)
for i in range(len(inputImages)):
idenList=inputImages[i].split('/')[2].split('-')
run=int(idenList[0])
camcol=int(idenList[1])
field=int(idenList[2])
band=idenList[3].split('.')[0]
fitsFile=fits.open(inputImages[i])
fitsImage=fitsFile[0].data
errorData=fitsFile[1].data
errorImg=[]
for j in range(1489):
errorImg.append(errorData)
errorImage=np.asarray(errorImg)
skyImageInit=fitsFile[2].data[0][0]
xs=np.fromfunction(lambda k: k, (skyImageInit.shape[0],), dtype=int)
ys=np.fromfunction(lambda k: k, (skyImageInit.shape[1],), dtype=int)
interpolator=interp2d(xs, ys, skyImageInit, kind='cubic')
for j in range(errorImage.shape[1]):
for k in range(errorImage.shape[0]):
skyImageValue=interpolator.__call__(j*skyImageInit.shape[0]/errorImage.shape[0],k*skyImageInit.shape[1]/errorImage.shape[1])
errorImage[k][j]=return_sdss_pixelError(band, camcol, run, fitsImage[k][j], skyImageValue, errorImg[k][j])
fitsFile[0].data=errorImage
fitsFile.writeto(intErrorImages[i])
mw.reproject(intErrorImages,outputErrorImages,header=headerName,north_aligned=True,system='EQUJ',exact_size=True,common=True,silent_cleanup=True)
def _Slices(Beta, legendre_orders, smoothing=0):
"""Convolve Beta with a Gaussian function of 1/e width smoothing.
"""
pol = len(legendre_orders)
NP = len(Beta[0]) # number of points in 3_d plot.
index = range(NP)
Beta_convol = np.zeros((pol, NP))
Slice_3D = np.zeros((pol, 2*NP, 2*NP))
# Convolve Beta's with smoothing function
if smoothing > 0:
# smoothing function
Basis_s = np.fromfunction(lambda i: np.exp(-(i - (NP)/2)**2 /
(2*smoothing**2))/(smoothing*2.5), (NP,))
for i in range(pol):
Beta_convol[i] = np.convolve(Basis_s, Beta[i], mode='same')
else:
Beta_convol = Beta
# Calculate ordered slices:
for i in range(pol):
Slice_3D[i] = np.fromfunction(lambda k, l: _SL(i, (k-NP), (l-NP),
Beta_convol, index, legendre_orders), (2*NP, 2*NP))
# Sum ordered slices up
Slice = np.sum(Slice_3D, axis=0)
return Slice, Beta_convol
def test_from_latlon(self):
data = np.fromfunction(lambda y, x: y * x, (800, 800))
lons = np.fromfunction(lambda y, x: x, (10, 10))
lats = np.fromfunction(lambda y, x: 50 - (5.0 / 10) * y, (10, 10))
#source_def = grid.AreaDefinition.get_from_area_def(self.area_def)
source_def = self.area_def
res = grid.get_image_from_lonlats(lons, lats, source_def, data)
expected = np.array([[129276., 141032., 153370., 165804., 178334., 190575.,
202864., 214768., 226176., 238080.],
[133056., 146016., 158808., 171696., 184320., 196992.,
209712., 222480., 234840., 247715.],
[137026., 150150., 163370., 177215., 190629., 203756.,
217464., 230256., 243048., 256373.],
[140660., 154496., 168714., 182484., 196542., 210650.,
224257., 238464., 251712., 265512.],
[144480., 158484., 173148., 187912., 202776., 217358.,
231990., 246240., 259920., 274170.],
[147968., 163261., 178398., 193635., 208616., 223647.,
238728., 253859., 268584., 283898.],
[151638., 167121., 182704., 198990., 214775., 230280.,
246442., 261617., 276792., 292574.],
[154980., 171186., 187860., 204016., 220542., 237120.,
253125., 269806., 285456., 301732.],
[158500., 175536., 192038., 209280., 226626., 243697.,
260820., 277564., 293664., 310408.],
[161696., 179470., 197100., 214834., 232320., 250236.,
267448., 285090., 302328., 320229.]])
self.assertTrue(
np.array_equal(res, expected), 'Sampling from lat lon failed')
def kerph2im(self,theta=0): """ adds up the sine transform for uv phases & then multiplies Kmat, the transfer matrix from uv phases to kernel phases. Returns image to kernel phase transfer matrix. """ # To make the image pixel centered: self.off = np.array([self.fov/2.-0.5, self.fov/2.-0.5]) # empty sine transform matrix: self.ph2im = np.zeros((len(self.uv), self.fov,self.fov)) self.sym2im = np.zeros((len(self.uv), self.fov,self.fov)) rotMatrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]) for q,one_uv in enumerate(self.uv): self.rcoord = np.dot(rotMatrix,one_uv) self.ph2im[q,:,:] = self.red[q]*np.fromfunction(self.ffs, (self.fov, self.fov)) self.sym2im[q,:,:] = self.red[q]*np.fromfunction(self.ffc, (self.fov,self.fov)) # flatten for matrix multiplication #self.ph2im = self.ph2im.reshape(len(self.uv), self.fov*self.fov) # Matrix multiply Kmat & flattened sin transform matrix self.kerim = np.dot(self.Kmat, self.ph2im.reshape(len(self.uv), self.fov*self.fov)) # Reshape back to image dimensions self.kerim = self.kerim.reshape(len(self.Kmat), self.fov,self.fov) return self.kerim, self.sym2im
def vertical_flip_map(rows, cols):
map_x = numpy.fromfunction(
lambda r, c: c, (rows, cols), dtype=numpy.float32)
map_y = numpy.fromfunction(
lambda r, c: rows - 1 - r, (rows, cols), dtype=numpy.float32)
return map_x, map_y
def test_custom_multi(self):
def wf1(dist):
return 1 - dist / 100000.0
def wf2(dist):
return 1
def wf3(dist):
return np.cos(dist) ** 2
data = np.fromfunction(lambda y, x: (y + x) * 10 ** -6, (5000, 100))
lons = np.fromfunction(
lambda y, x: 3 + (10.0 / 100) * x, (5000, 100))
lats = np.fromfunction(
lambda y, x: 75 - (50.0 / 5000) * y, (5000, 100))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
data_multi = np.column_stack((data.ravel(), data.ravel(),
data.ravel()))
with catch_warnings(UserWarning) as w:
res = kd_tree.resample_custom(swath_def, data_multi,
self.area_def, 50000, [wf1, wf2, wf3], segments=1)
self.assertFalse(len(w) != 1)
self.assertFalse('Possible more' not in str(w[0].message))
cross_sum = res.sum()
expected = 1461.8428378742638
self.assertAlmostEqual(cross_sum, expected)
def planeRegression(imgarray): """ performs a two-dimensional linear regression and subtracts it from an image essentially a fast high pass filter """ size = (imgarray.shape)[0] count = float((imgarray.shape)[0]*(imgarray.shape)[1]) def retx(y,x): return x def rety(y,x): return y xarray = numpy.fromfunction(retx, imgarray.shape) yarray = numpy.fromfunction(rety, imgarray.shape) xsum = float(xarray.sum()) xsumsq = float((xarray*xarray).sum()) ysum = xsum ysumsq = xsumsq xysum = float((xarray*yarray).sum()) xzsum = float((xarray*imgarray).sum()) yzsum = float((yarray*imgarray).sum()) zsum = imgarray.sum() zsumsq = (imgarray*imgarray).sum() xarray = xarray.astype(numpy.float32) yarray = yarray.astype(numpy.float32) leftmat = numpy.array( [[xsumsq, xysum, xsum], [xysum, ysumsq, ysum], [xsum, ysum, count]] ) rightmat = numpy.array( [xzsum, yzsum, zsum] ) resvec = linalg.solve(leftmat,rightmat) #print " ... plane_regress: x-slope:",round(resvec[0]*size,5),\ # ", y-slope:",round(resvec[1]*size,5),", xy-intercept:",round(resvec[2],5) newarray = imgarray - xarray*resvec[0] - yarray*resvec[1] - resvec[2] #del imgarray,xarray,yarray,resvec return newarray
def test_2():
Temp1, Temp2 = Temp, Temp/temp_ratio
double_temp = np.sqrt(Temp1*Temp2)
ss_temp = np.sqrt(Temp1) + np.sqrt(Temp2)
delta_temp = np.abs(Temp2 - Temp1)
Rho1, Rho2 = 2*Rho*np.sqrt(Temp2)/ss_temp, 2*Rho*np.sqrt(Temp1)/ss_temp
f = Rho1/(np.pi*Temp1)**1.5 * np.fromfunction(lambda i,j,k: np.exp(-sqr_xi(i,j,k,Speed)/(Temp1))*dxi(i,j,k), dimension)
negative = np.fromfunction(lambda i,j,k: j<N_y, dimension)
f[negative] = Rho2/(np.pi*Temp2)**1.5 * np.fromfunction(lambda i,j,k: np.exp(-sqr_xi(i,j,k,-Speed)/(Temp2))*dxi(i,j,k), dimension)[negative]
rho, temp, speed, qflow, tau = calc_macro(f)
Rho_ = Rho
Temp_ = double_temp * (1 + 8./3*np.dot(Speed,Speed)/ss_temp**2)
Speed_ = -Speed * delta_temp / ss_temp**2
Qflow_ = [ 0, 2*Rho*double_temp*delta_temp/ss_temp/np.sqrt(np.pi) * (1 + 2*np.dot(Speed,Speed)/ss_temp**2), 0 ]
Tau_ = [ 0, 0, 4*Rho*Speed[0]*double_temp/ss_temp/np.sqrt(np.pi) ]
#splot(f)
#splot(f*c[0]*c[1])
print "\n-- Test #2: free molecular flows - sum of 2 half-Maxwellians"
print "rho =", err(Rho_, rho)
print "temp =", err(Temp_, temp)
print "speed =", err(Speed_, speed)
print "qflow =", err(Qflow_, qflow/rho)
print "tau =", err(Tau_, tau/rho)
def test_gauss_multi_uncert(self):
data = np.fromfunction(lambda y, x: (y + x) * 10 ** -6, (5000, 100))
lons = np.fromfunction(
lambda y, x: 3 + (10.0 / 100) * x, (5000, 100))
lats = np.fromfunction(
lambda y, x: 75 - (50.0 / 5000) * y, (5000, 100))
swath_def = geometry.SwathDefinition(lons=lons, lats=lats)
data_multi = np.column_stack((data.ravel(), data.ravel(),
data.ravel()))
with catch_warnings(UserWarning) as w:
# The assertion below checks if there is only one warning raised
# and whether it contains a specific message from pyresample
# On python 2.7.9+ the resample_gauss method raises multiple deprecation warnings
# that cause to fail, so we ignore the unrelated warnings.
res, stddev, counts = kd_tree.resample_gauss(swath_def, data_multi,
self.area_def, 50000, [
25000, 15000, 10000],
segments=1, with_uncert=True)
self.assertTrue(len(w) >= 1)
self.assertTrue(
any(['Possible more' in str(x.message) for x in w]))
cross_sum = res.sum()
cross_sum_counts = counts.sum()
expected = 1461.8429990248171
expected_stddev = [0.44621800779801657, 0.44363137712896705,
0.43861019464274459]
expected_counts = 4934802.0
self.assertTrue(res.shape == stddev.shape and stddev.shape ==
counts.shape and counts.shape == (800, 800, 3))
self.assertAlmostEqual(cross_sum, expected)
for i, e_stddev in enumerate(expected_stddev):
cross_sum_stddev = stddev[:, :, i].sum()
self.assertAlmostEqual(cross_sum_stddev, e_stddev)
self.assertAlmostEqual(cross_sum_counts, expected_counts)
def horizontal_flip_map(rows, cols):
map_x = numpy.fromfunction(
lambda r, c: cols - 1 - c, (rows, cols), dtype=numpy.float32)
map_y = numpy.fromfunction(
lambda r, c: r, (rows, cols), dtype=numpy.float32)
return map_x, map_y
def __set_pm__(L, window, taps, fwidth):
global pm
if pm['L'] == L and pm['taps'] == taps and pm['fwidth'] == fwidth:
if type(window) == str and pm['window_name'] == window: return
elif window is pm['window']: return
else:
pm['L'] = L
pm['taps'] = taps
pm['fwidth'] = fwidth
def sinx_x(x):
t = n.pi * taps * fwidth * (x/float(L) - .5)
v = n.where(t != 0, t, 1)
return n.where(t != 0, n.sin(v) / v, 1)
pm['sinx_x'] = n.fromfunction(sinx_x, (L,))
if type(window) == str:
wf = {}
wf['hamming'] = lambda x: .54 + .46 * cos(2*n.pi*x/L - n.pi)
wf['hanning'] = lambda x: .5 + .5 * n.cos(2*n.pi*x/(L+1) - n.pi)
wf['none'] = lambda x: 1
pm['window'] = n.fromfunction(wf[window], (L,))
pm['window_name'] = window
else:
pm['window'] = window
pm['window_name'] = None
pm['window_sinx_x'] = pm['window'] * pm['sinx_x']
def make_gauss_init(pkinit, boxsize=100.0, ngrid=100, seed=314159, exactpk=True, smw=2.0):
#mathematical artifact of Fourier transform, possibly incorrect? (ngrid+1)/2)
thirdim = ngrid/2+1
#inverse(?) of the cell size (in 2pi)
kmin = 2*np.pi/np.float(boxsize)
#shape of k grid
sk = (ngrid,ngrid,thirdim)
#No clue. it represents the grid, but the method / definition is non-trivial.
a = np.fromfunction(lambda x,y,z:x, sk).astype(np.float)
a[np.where(a > ngrid/2)] -= ngrid
b=np.transpose(a, (1, 0, 2))
c = np.fromfunction(lambda x,y,z:z, sk).astype(np.float)
c[np.where(c > ngrid/2)] -= ngrid
#From this, a/b/c = x/y/z but why are 3x10x10x6 arrays necessary?
kgrid = kmin*np.sqrt(a**2+b**2+c**2).astype(np.float)
a = 0
b = 0
c = 0
#K-space is a bitch.
#self-explanatory
rs = np.random.RandomState(seed)
#What are these complex numbers representing?
if (exactpk):
dk = np.exp(2j*np.pi*rs.rand(ngrid*ngrid*(thirdim))).reshape(sk).astype(np.complex64)
else:
dk = np.empty(sk,dtype=np.complex64)
dk.real = rs.normal(size=ngrid*ngrid*(thirdim)).reshape(sk).astype(np.float32)
dk.imag = rs.normal(size=ngrid*ngrid*(thirdim)).reshape(sk).astype(np.float32)
dk /= np.sqrt(2.0)
#This section provides a unit length, random(?) phase complex number associated with
#each point on the grid.
#Gaussian filter
filt=np.exp(-kgrid**2*smw**2)
#interpolate power spectrum to approximate at non-keyed values.
pkinterp=ip.interp1d(pkinit[:,0], pkinit[:,1])
#Pk undefined at 0, so this provides an explicit exception.
if (kgrid[0,0,0]==0):
dk[0,0,0]=0
wn0=np.where(kgrid!=0)
#The mathematics?
dk[wn0] *= np.sqrt(filt[wn0]*pkinterp(kgrid[wn0]))*ngrid**3/boxsize**1.5
#Why is this if statement necessary? We know the P(k) will be undefined.
else:
dk *= np.sqrt(filt*pkinterp(kgrid.flatten())).reshape(sk)*ngrid**3/boxsize**1.5
dk=nyquist(dk)
return dk
import numpy as np
import pyresample as pr
print(pr.version.get_versions())
area_def = pr.geometry.AreaDefinition(
'areaD', 'Europe (3km, HRV, VTC)', 'areaD', {
'a': '6378144.0',
'b': '6356759.0',
'lat_0': '50.00',
'lat_ts': '50.00',
'lon_0': '8.00',
'proj': 'stere'
}, 800, 800, [-1370912.72, -909968.64, 1029087.28, 1490031.36])
data = np.fromfunction(lambda y, x: y * x, (50, 10))
lons = np.fromfunction(lambda y, x: 3 + x, (50, 10))
lats = np.fromfunction(lambda y, x: 75 - y, (50, 10))
swath_def = pr.geometry.SwathDefinition(lons=lons, lats=lats)
mapcenter = [-111.4223, 34.7443]
clon = mapcenter[0]
clat = mapcenter[1]
latMin = clat - 5
latMax = clat + 5
lonMin = clon - 5
lonMax = clon + 5
gridRes = 1
def fromfunction(args, dimensions):
return np.fromfunction(args, dimensions, dtype=int)
def planeGen():
for p in range(sizeZ * sizeC * sizeT):
yield fromfunction(f, (sizeY, sizeX), dtype=int16)
LY = 2.3
DX = LX / NX
DY = LY / NY
X0 = 1.0
Y0 = 2.0
amplitude = 2.0
def nonGroundedWall(Yindex):
return amplitude * np.sin(np.pi * Yindex / NY)
# Boundary conditions
V0x = dirBC(np.zeros((NY + 1)))
VNx = dirBC(np.fromfunction(nonGroundedWall, (NY + 1, )))
V0y = dirBC(np.zeros((NX + 1)))
VNy = dirBC(np.zeros((NX + 1)))
start = time.time()
potential_1 = laplace2D(NX,
DX,
V0x,
VNx,
NY,
DY,
V0y,
VNy,
"gaussSeidel",
def plot_head_outline(scale=1,
shift=(0, 0),
color='k',
linewidth='3',
ax=P,
view='top',
**kwargs):
"""Plots a simple outline of a head viewed from the top.
The plot contains schematic representations of the nose and ears. The
size of the head is basically a unit circle for nose and ears attached
to it.
:Parameters:
scale: float
Factor to scale the size of the head.
shift: 2-tuple of floats
Shift the center of the head circle by these values.
color: matplotlib color spec
The color the outline should be plotted in.
linewidth: int
Linewidth of the head outline.
ax: mpl axes
axes to plot to. Standard is pylab.
view: one of 'top' and 'rear'
Defines from where the head is viewed.
kwargs:
All additional arguments are passed to `P.plot()`.
:Returns:
Matplotlib lines2D object
can be used to tweak the look of the head outline.
"""
rmax = 0.5
# factor used all the time
fac = 2 * N.pi * 0.01
if view == 'top':
# Koordinates for the ears
EarX1 = -1 * N.array([
.497, .510, .518, .5299, .5419, .54, .547, .532, .510,
rmax * N.cos(fac * (54 + 42))
])
EarY1 = N.array([
.0655, .0775, .0783, .0746, .0555, -.0055, -.0932, -.1313, -.1384,
rmax * N.sin(fac * (54 + 42))
])
EarX2 = N.array([
rmax * N.cos(fac * (54 + 42)), .510, .532, .547, .54, .5419, .5299,
.518, .510, .497
])
EarY2 = N.array([
rmax * N.sin(fac * (54 + 42)), -.1384, -.1313, -.0932, -.0055,
.0555, .0746, .0783, .0775, .0655
])
# Coordinates for the Head
HeadX1 = N.fromfunction(lambda x: rmax * N.cos(fac * (x + 2)), (21, ))
HeadY1 = N.fromfunction(lambda y: rmax * N.sin(fac * (y + 2)), (21, ))
HeadX2 = N.fromfunction(lambda x: rmax * N.cos(fac * (x + 28)), (21, ))
HeadY2 = N.fromfunction(lambda y: rmax * N.sin(fac * (y + 28)), (21, ))
HeadX3 = N.fromfunction(lambda x: rmax * N.cos(fac * (x + 54)), (43, ))
HeadY3 = N.fromfunction(lambda y: rmax * N.sin(fac * (y + 54)), (43, ))
# Coordinates for the Nose
NoseX = N.array([.18 * rmax, 0, -.18 * rmax])
NoseY = N.array([rmax - 0.004, rmax * 1.15, rmax - 0.004])
# Combine to one
X = N.concatenate((EarX2, HeadX1, NoseX, HeadX2, EarX1, HeadX3))
Y = N.concatenate((EarY2, HeadY1, NoseY, HeadY2, EarY1, HeadY3))
X *= 2 * scale
Y *= 2 * scale
X += shift[0]
Y += shift[1]
elif view == 'rear':
# Koordinates for the ears
EarX1 = -1 * N.array([
.497, .510, .518, .5299, .5419, .54, .537, .525, .510,
rmax * N.cos(fac * (54 + 42))
])
EarY1 = N.array([
.0655, .0775, .0783, .0746, .0555, -.0055, -.0932, -.1713, -.1784,
rmax * N.sin(fac * (54 + 42))
])
EarX2 = N.array([
rmax * N.cos(fac * (54 + 42)), .510, .525, .537, .54, .5419, .5299,
.518, .510, .497
])
EarY2 = N.array([
rmax * N.sin(fac * (54 + 42)), -.1784, -.1713, -.0932, -.0055,
.0555, .0746, .0783, .0775, .0655
])
# Coordinates for the Head
HeadX1 = N.fromfunction(lambda x: rmax * N.cos(fac * (x + 2)), (23, ))
HeadY1 = N.fromfunction(lambda y: rmax * N.sin(fac * (y + 2)), (23, ))
HeadX2 = N.fromfunction(lambda x: rmax * N.cos(fac * (x + 26)), (23, ))
HeadY2 = N.fromfunction(lambda y: rmax * N.sin(fac * (y + 26)), (23, ))
HeadX3 = N.fromfunction(lambda x: rmax * N.cos(fac * (x + 54)), (17, ))
HeadY3 = N.fromfunction(lambda y: rmax * N.sin(fac * (y + 54)), (17, ))
HeadX4 = N.fromfunction(lambda x: rmax * N.cos(fac * (x + 80)), (17, ))
HeadY4 = N.fromfunction(lambda y: rmax * N.sin(fac * (y + 80)), (17, ))
# Coordinates for the Neck
NeckX = N.array([rmax * N.cos(fac * 70), rmax * N.cos(fac * 80)])
NeckY = N.array([rmax * -1.1, rmax * -1.1])
# Combine to one
X = N.concatenate(
(EarX2, HeadX1, HeadX2, EarX1, HeadX3, NeckX, HeadX4))
Y = N.concatenate(
(EarY2, HeadY1, HeadY2, EarY1, HeadY3, NeckY, HeadY4))
X *= 2 * scale
Y *= 2 * scale
X += shift[0]
Y += shift[1]
else:
raise ValueError("view must be one of 'top' and 'rear'")
return ax.plot(X, Y, color=color, linewidth=linewidth)
def mascara_nubes(img_bgr, centroide=None):
'''
Función que genera la máscara de nubes de una imágen según el método propio.
Parameters
----------
img_bgr :
Imagen original.
centroide : list, (Y,X)
Posición del sol.
En el caso de que se indique, se eliminará
el contorno que encierre al centroide,
según el algoritmo propuesto.
Returns
-------
mask_cloud
'''
# Separación de los canales de la imagen:
Blue = img_bgr[:, :, 0]
Green = img_bgr[:, :, 1]
Red = img_bgr[:, :, 2]
# Método propio en base a las máscaras de los canales
mask_green = cv2.inRange(Green, 0, 140)
mask_red = cv2.inRange(Red, 0, 70)
mask_R_B = cv2.inRange(Red - Blue, 90, 255)
mask_B_G = cv2.inRange(Blue - Green, 30, 255)
# Creación de las máscaras de cielo despejado
mask_sky = cv2.bitwise_or(mask_R_B, mask_green, mask=mask_B_G)
mask_sky = cv2.bitwise_or(mask_sky, mask_red, mask=mask_B_G)
mask_sky = cv2.bitwise_and(mask_sky, mask_sky, mask=cielo)
# Se crea la máscara de las nubes negando la máscara del cielo despejado
mask_cloud = cv2.bitwise_not(mask_sky)
mask_cloud = cv2.bitwise_and(mask_cloud, mask_cloud, mask=cielo)
# Si se indica centroide, se elimina la falsa nube que se puede detectar en casos en los que el sol sature la cámara
if centroide != None:
# Se obtiene los contornos de las nubes
mask_cloud = cv2.medianBlur(mask_cloud.astype(np.uint8), 5)
cnt_nubes, hierarchy = cv2.findContours(mask_cloud, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
# Se obtiene el contorno de nube que encierra al centroide:
for i in cnt_nubes:
if cv2.pointPolygonTest(i, centroide, False) >= 0:
cnt_sol = i
# Se obtiene la máscara en la que se encuentra la "sombra" del sol, con el fin de quitar esta zona de la máscara de nubes
# f_mask_sol = lambda pos: 255 if (cv2.pointPolygonTest(cnt_sol, pos, False) >= 0) else 0
# mask_sol = [[f_mask_sol((y,x)) for y in range(Y)] for x in range(X)]
# mask_sol = np.array(mask_sol, np.uint8)
f_mask_sol = lambda x, y: 255 if (cv2.pointPolygonTest(
cnt_sol, (y, x), False) >= 0) else 0
mask_sol = np.fromfunction(np.vectorize(f_mask_sol), (X, Y),
dtype=int).astype(np.uint8)
mask_no_sol = cv2.bitwise_not(mask_sol)
mask_cloud = cv2.bitwise_and(mask_cloud, mask_no_sol)
return mask_cloud
print("Max",a.max())
b=np.arange(12).reshape(3,4)
print("Somatorio do primeiro eixo",b.sum(axis=0))
print("min do segundo eixo",b.min(axis=1))
print("Somatorio acumulado do primeiro eixo",b.cumsum(axis=0))#integração
a=np.arange(10)**3
print(a[2])
print(a[2:5])
a[:6:2]=-1000#susbtitui
print(a)
print(a[::-1])#inverte a posição
for i in a:
print(i**(1/3))
def f(x,y):
return 10*x+y
b=np.fromfunction(f,(5,4),dtype=int)
print(b)
print(b[2,3])
print(b[0:5,1])
c=np.array([[[0, 1, 2],[10, 12, 13]],[[100, 101, 102],[110, 112, 113]]])
print(c)
print(c[-1])
print(c[1,...])#pegar tudo na linha 1
#Pegar toda uma linha
for row in c:
print(row)
for element in c.flat:
print(element)
a=np.random.random((2,3))
print(a.T)#transposta
print(a.resize(3,2))#reshape que n retorna nada
reveal_type(np.full_like(A, i8)) # E: numpy.ndarray reveal_type(np.full_like(C, i8)) # E: numpy.ndarray reveal_type(np.full_like(B, i8)) # E: SubClass reveal_type(np.full_like(B, i8, dtype=np.int64)) # E: numpy.ndarray reveal_type(np.ones(1)) # E: numpy.ndarray reveal_type(np.ones([1, 1, 1])) # E: numpy.ndarray reveal_type(np.full(1, i8)) # E: numpy.ndarray reveal_type(np.full([1, 1, 1], i8)) # E: numpy.ndarray reveal_type(np.indices([1, 2, 3])) # E: numpy.ndarray reveal_type(np.indices([1, 2, 3], sparse=True)) # E: tuple[numpy.ndarray] reveal_type(np.fromfunction(func, (3, 5))) # E: SubClass reveal_type(np.identity(10)) # E: numpy.ndarray reveal_type(np.atleast_1d(A)) # E: numpy.ndarray reveal_type(np.atleast_1d(C)) # E: numpy.ndarray reveal_type(np.atleast_1d(A, A)) # E: list[numpy.ndarray] reveal_type(np.atleast_1d(A, C)) # E: list[numpy.ndarray] reveal_type(np.atleast_1d(C, C)) # E: list[numpy.ndarray] reveal_type(np.atleast_2d(A)) # E: numpy.ndarray reveal_type(np.atleast_3d(A)) # E: numpy.ndarray reveal_type(np.vstack([A, A])) # E: numpy.ndarray reveal_type(np.vstack([A, C])) # E: numpy.ndarray
particle_force1 = np.copy(system.part[1].f)
checkpoint.register("particle_force0")
checkpoint.register("particle_force1")
if espressomd.has_features("COLLISION_DETECTION"):
system.collision_detection.set_params(mode="bind_centers",
distance=0.11,
bond_centers=harmonic_bond)
if LB_implementation:
m = np.pi / 12
nx = int(np.round(system.box_l[0] / lbf.get_params()["agrid"]))
ny = int(np.round(system.box_l[1] / lbf.get_params()["agrid"]))
nz = int(np.round(system.box_l[2] / lbf.get_params()["agrid"]))
# Create a 3D grid with deterministic values to fill the LB fluid lattice
grid_3D = np.fromfunction(
lambda i, j, k: np.cos(i * m) * np.cos(j * m) * np.cos(k * m),
(nx, ny, nz),
dtype=float)
for i in range(nx):
for j in range(ny):
for k in range(nz):
lbf[i, j, k].population = grid_3D[i, j, k] * np.arange(1, 20)
cpt_mode = int("@TEST_BINARY@")
# save LB checkpoint file
lbf_cpt_path = checkpoint.checkpoint_dir + "/lb.cpt"
lbf.save_checkpoint(lbf_cpt_path, cpt_mode)
if EK_implementation:
m = np.pi / 12
nx = int(np.round(system.box_l[0] / ek.get_params()["agrid"]))
ny = int(np.round(system.box_l[1] / ek.get_params()["agrid"]))
nz = int(np.round(system.box_l[2] / ek.get_params()["agrid"]))
# xx= xx /s1 * (g1-1)
# return yy,xx
if __name__ == '__main__':
#this example shows extrapolation on an offset grid
#where first and last row/column are skewed depending
#on the size of [offs]
import pylab as plt
import sys
from imgProcessor.interpolate.polyfit2d import polyfit2dGrid
g = (7,10)#small grid size
small = np.fromfunction(lambda x,y: np.sin(7*x/g[0])
+np.cos(9*y/g[1]), g)
g2 = (70,100) #big grid size
if 'no_window' not in sys.argv:
f, ax = plt.subplots(3,2)
for i, offs in zip( (0,1,2), ((0,0),(8,9),(-5,-3)) ):
########
yy,xx = offsetMeshgrid(offs, g, g2)
big = polyfit2dGrid(small, outgrid=(yy,xx),
order=7)
#######
if 'no_window' not in sys.argv:
ax[i,0].set_title('input data')
ax[i,0].imshow(small, interpolation='none')
def model_array(ctrs, lam, oversample, pitch, fov, d,
centering='PIXELCENTERED', shape='circ'):
"""
Short Summary
-------------
Create a model using the specified wavelength.
Parameters
----------
ctrs: 2D float array
centers of holes
lam: float
wavelength in the bandpass for this particular model
oversample: integer
oversampling factor
pitch: float
sampling pitch in radians in image plane
fov: integer
number of detector pixels on a side.
d: float
hole diameter for 'circ'; flat to flat distance for 'hex
centering: string
subpixel centering; for now only option is PIXELCENTERED, which means
putting the brightest detector pixel at the center of the trimmed data
frame or simulated image.
shape: string
shape of hole; possible values are 'circ', 'hex', and 'fringe'
Returns
-------
if 'shape' == 'circ', returns the primary beam (2D float array)
for circular holes.
if 'shape' == 'hex', returns the primary beam (2D float array)
for hexagonal holes.
ffmodel: list of 3 2D float arrays
model array
"""
if centering == 'PIXELCORNER':
off = np.array([0.0, 0.0])
elif centering == 'PIXELCENTERED':
off = np.array([0.5, 0.5])
else:
off = centering
log.debug('------------------')
log.debug('Model Parameters:')
log.debug('------------------')
log.debug('pitch:%s fov:%s oversampling:%s ', pitch, fov, oversample)
log.debug('centers:%s', ctrs)
log.debug('wavelength:%s centering:%s off:%s ', lam, centering, off)
log.debug('shape:%s d:%s ', shape, d)
#### dg - should I make some of the next blocks new/separate functions ?
# primary beam parameters:
primarybeam.shape = shape
primarybeam.lam = lam
primarybeam.size = (oversample * fov, oversample * fov)
primarybeam.offx = oversample * fov / 2.0 - off[0] # in pixels
primarybeam.offy = oversample * fov / 2.0 - off[1]
primarybeam.pitch = pitch / float(oversample)
primarybeam.d = d
hexpb.shape = shape
hexpb.lam = lam
hexpb.size = (oversample * fov, oversample * fov)
hexpb.offx = oversample * fov / 2.0 - off[0] # in pixels
hexpb.offy = oversample * fov / 2.0 - off[1]
hexpb.pitch = pitch / float(oversample)
hexpb.d = d
# model fringe matrix parameters:
ffc.N = len(ctrs) # number of holes
ffc.lam = lam
ffc.over = oversample
ffc.pitch = pitch / float(oversample)
ffc.size = (oversample * fov, oversample * fov)
ffc.offx = oversample * fov / 2.0 - off[0]
ffc.offy = oversample * fov / 2.0 - off[1]
ffs.N = len(ctrs) # number of holes
ffs.lam = lam
ffs.over = oversample
ffs.pitch = pitch / float(oversample)
ffs.size = (oversample * fov, oversample * fov)
ffs.offx = oversample * fov / 2.0 - off[0]
ffs.offy = oversample * fov / 2.0 - off[1]
alist = []
for i in range(ffc.N - 1):
for j in range(ffc.N - 1):
if j + i + 1 < ffc.N:
alist = np.append(alist, i)
alist = np.append(alist, j + i + 1)
alist = alist.reshape(len(alist) // 2, 2)
ffmodel = []
ffmodel.append(ffc.N * np.ones(ffc.size))
for q, r in enumerate(alist):
# r[0] and r[1] are holes i and j, x-coord: 0, y-coord: 1
ffc.ri = ctrs[int(r[0])]
ffc.rj = ctrs[int(r[1])]
ffs.ri = ctrs[int(r[0])]
ffs.rj = ctrs[int(r[1])]
ffmodel.append(np.fromfunction(ffc, ffc.size))
ffmodel.append(np.fromfunction(ffs, ffs.size))
if shape == 'circ': # if unspecified (default), or specified as 'circ'
return np.fromfunction(primarybeam, ffc.size), ffmodel
elif shape == 'hex':
return hexpb(), ffmodel
else:
log.critical('Must provide a valid hole shape. Current supported shapes \
are circ and hex.')
return None
def first_cancel(array):
import numpy
cancel = numpy.fromfunction(lambda i: -(array[0] - array[-1]) / array.shape[0]\
* i + array[0], (array.shape[0],), dtype=array.dtype)
return array - cancel
cu[5] = (c[5, 0] * u[0] + c[5, 1] * u[1])
cu[6] = (c[6, 0] * u[0] + c[6, 1] * u[1])
cu[7] = (c[7, 0] * u[0] + c[7, 1] * u[1])
cu[8] = (c[8, 0] * u[0] + c[8, 1] * u[1])
usqr = (u[0] * u[0] + u[1] * u[1])
#feq = np.empty((q, xsize, ysize))
feq = np.zeros((9, xsize, ysize), dtype=float).astype(np.float32)
for i in range(q):
feq[i, :, :] = rho * t[i] * (
1. + 3.0 * cu[i] + 9 * 0.5 * cu[i] * cu[i] - 3.0 * 0.5 * usqr)
return feq
LeftWall = np.fromfunction(lambda x, y: x == 0, (xsize, ysize))
RightWall = np.fromfunction(lambda x, y: x == xsize_max, (xsize, ysize))
BottomWall = np.fromfunction(lambda x, y: y == ysize_max, (xsize, ysize))
wall = np.logical_or(np.logical_or(LeftWall, RightWall), BottomWall)
# velocity initial/boundary conditions
InitVel = np.zeros((2, xsize, ysize))
InitVel[0, :, 0] = uLB
u[:] = InitVel[:]
# initial distributions
feq = equ(rho, InitVel)
np.copyto(fin, feq)
np.copyto(ftemp, feq)
np.copyto(fpost, feq)
def disc(r):
r2 = r//2
t = np.fromfunction(lambda x,y: (x-r2)**2+(y-r2)**2 <=r2**2,(r,r))
w = np.zeros((r,r))
w[t]=1
return w
VlocRN = np.zeros(order)
VexRN = np.zeros((order, order))
nu = mu * omega / (2 * hbar)
for y in range(NState):
for x in range(order):
psiRN[x, y] = psi(t[x], y, Lrel, nu)
ddpsiRN[x, y] = ddpsi(t[x], y, Lrel, nu)
VlocRN[:] = pot_local(t[:],
potargs) + mh2 * Lrel * (Lrel + 1) / t[:]**2
if (interaction == "NonLocal"):
VexRN = np.fromfunction(
lambda x, y: exchange_kernel(t[x], t[y], potargs),
(order, order),
dtype=int)
VnolRN = np.fromfunction(
lambda x, y: pot_nonlocal(t[x], t[y], potargs),
(order, order),
dtype=int)
# fill the lower triangular matrices only and exploit the symmetry
# ECCE: I reduced the calculation to one loop
for i in np.arange(NState):
for j in np.arange(i + 1):
U[i][j] = np.sum(
psiRN[:, i] * psiRN[:, j] * w[:]) * gauss_scale
U[j][i] = U[i][j]
Kin[i][j] = np.sum(
psiRN[:, i] * ddpsiRN[:, j] * w[:]) * gauss_scale
def getA(n):
return np.fromfunction(lambda i, j: 1 / (i + j + 1), (n, n))
def matrix(E):
A = np.fromfunction(lambda i, ii: V(x(ii))*G(np.abs(x(i)-x(ii)),E), (nx,nx))
A = 2*A*dx
return A
Vk2 = np.fft.fftshift(Vk2, axes=(0, 1))
Vk3 = np.fft.fftshift(Vk3, axes=(0, 1))
print("--- %s seconds ---" % (time.time() - start_time))
np.savetxt('vk1_shift' + str(filenumber) + '.txt',
np.absolute(Vk1[20][70]))
#Square and add the absolute values of Vk1, Vk2, Vk3
Vk_sq = np.add(
np.add(np.square(np.absolute(Vk1)), np.square(np.absolute(Vk2))),
np.square(np.absolute(Vk3)))
#Write k_sq as a functional 3d array, with value at each element given by (nx/2-i)^2+(ny/2-j)^2+(k)^2
k_sq = np.fromfunction(
lambda i, j, k: (i - n[0] / 2)**2 + (j - n[1] / 2)**2 + k**2,
np.shape(Vk1))
#Energy density is given by Vk^2
E_k = Vk_sq
#Flatten E_k and k now, and store them in a single 2D array
K = np.transpose(
np.vstack((np.ndarray.flatten(k_sq), np.ndarray.flatten(E_k))))
#K[][0] stores k, K[][1] stores E(k).
print("--- %s seconds ---" % (time.time() - start_time))
#The following code adds up E(k) values for the same k^2
def __fromfunction(f, s, t):
return N.fromfunction(f,s).astype(t)
def GeneralizedFFT(Input,b=1.0,a=0.0): dim = len(Input) print 'numpy.shape(Input) = ',numpy.shape(Input) t1 = numpy.fromfunction(lambda X,Y: 2.0*pi*complex(0.0,1.0)*b*(X-1.0)*(Y-1.0)/dim,shape=[dim,dim]) t1 = numpy.exp(t1) return (pow(dim,-(1.0-a)/2.0)*numpy.tensordot(Input,t1,axes=([0],[0])))
y = j - offset[1]
z = k - offset[2]
th = np.arctan2(z, (x**2 + y**2)**0.5)
phi = np.arctan2(y, x)
r = (x**2 + y**2 + z**2)**0.5
a0 = 2
#ps = (1./81.) * (2./np.pi)**0.5 * (1./a0)**(3/2) * (6 - r/a0) * (r/a0) * np.exp(-r/(3*a0)) * np.cos(th)
ps = (1. / 81.) * 1. / (6. * np.pi)**0.5 * (1. / a0)**(3 / 2) * (
r / a0)**2 * np.exp(-r / (3 * a0)) * (3 * np.cos(th)**2 - 1)
return ps
#return ((1./81.) * (1./np.pi)**0.5 * (1./a0)**(3/2) * (r/a0)**2 * (r/a0) * np.exp(-r/(3*a0)) * np.sin(th) * np.cos(th) * np.exp(2 * 1j * phi))**2
data = np.fromfunction(psi, (100, 100, 200))
positive = np.log(np.clip(data, 0, data.max())**2)
negative = np.log(np.clip(-data, 0, -data.min())**2)
d2 = np.empty(data.shape + (4, ), dtype=np.ubyte)
d2[..., 0] = positive * (255. / positive.max())
d2[..., 1] = negative * (255. / negative.max())
d2[..., 2] = d2[..., 1]
d2[..., 3] = d2[..., 0] * 0.3 + d2[..., 1] * 0.3
d2[..., 3] = (d2[..., 3].astype(float) / 255.)**2 * 255
d2[:, 0, 0] = [255, 0, 0, 100]
d2[0, :, 0] = [0, 255, 0, 100]
d2[0, 0, :] = [0, 0, 255, 100]
v = gl.GLVolumeItem(d2)
def generate_radiation(x, y, size=700): return np.fromfunction(dose(x, y), (size, size))
self._last_time = t
self.shared_program['time'] = self._time
self.update()
VectorField = scene.visuals.create_visual_node(VectorFieldVisual)
def fn(y, x):
dx = x - 50
dy = y - 30
l = (dx**2 + dy**2)**0.5 + 0.01
return np.array([100 * dy / l**1.7, -100 * dx / l**1.8])
field = np.fromfunction(fn, (100, 100)).transpose(1, 2, 0).astype('float32')
field[..., 0] += 10 * np.cos(np.linspace(0, 2 * 3.1415, 100))
color = np.zeros((100, 100, 4), dtype='float32')
color[..., :2] = (field + 5) / 10.
color[..., 2] = 0.5
color[..., 3] = 0.5
canvas = scene.SceneCanvas(keys='interactive', show=True)
view = canvas.central_widget.add_view(camera='panzoom')
vfield = VectorField(field[..., :2],
spacing=0.5,
segments=30,
seg_len=0.05,
parent=view.scene,
def eeg_plot_head_outline(scale=1,
shift=(0, 0),
color='k',
linewidth='5',
**kwargs):
"""Plots a simple outline of a head viewed from the top.
Function borrowed from the PyMVPA package (http://www.pymvpa.org)
see e.g., https://github.com/PyMVPA/PyMVPA/blob/master/mvpa2/misc/plot/topo.py
The plot contains schematic representations of the nose and ears. The
size of the head is basically a unit circle for nose and ears attached
to it.
Parameters
----------
scale : float
Factor to scale the size of the head.
shift : 2-tuple of floats
Shift the center of the head circle by these values.
color : matplotlib color spec
The color the outline should be plotted in.
linewidth : int
Linewidth of the head outline.
**kwargs
All additional arguments are passed to `pylab.plot()`.
Returns
-------
Matplotlib lines2D object
can be used to tweak the look of the head outline.
"""
rmax = 0.5
# factor used all the time
fac = 2 * np.pi * 0.01
# Koordinates for the ears
EarX1 = -1 * np.array([
.497, .510, .518, .5299, .5419, .54, .547, .532, .510,
rmax * np.cos(fac * (54 + 42))
])
EarY1 = np.array([
.0655, .0775, .0783, .0746, .0555, -.0055, -.0932, -.1313, -.1384,
rmax * np.sin(fac * (54 + 42))
])
EarX2 = np.array([
rmax * np.cos(fac * (54 + 42)), .510, .532, .547, .54, .5419, .5299,
.518, .510, .497
])
EarY2 = np.array([
rmax * np.sin(fac * (54 + 42)), -.1384, -.1313, -.0932, -.0055, .0555,
.0746, .0783, .0775, .0655
])
# Coordinates for the Head
HeadX1 = np.fromfunction(lambda x: rmax * np.cos(fac * (x + 2)), (21, ))
HeadY1 = np.fromfunction(lambda y: rmax * np.sin(fac * (y + 2)), (21, ))
HeadX2 = np.fromfunction(lambda x: rmax * np.cos(fac * (x + 28)), (21, ))
HeadY2 = np.fromfunction(lambda y: rmax * np.sin(fac * (y + 28)), (21, ))
HeadX3 = np.fromfunction(lambda x: rmax * np.cos(fac * (x + 54)), (43, ))
HeadY3 = np.fromfunction(lambda y: rmax * np.sin(fac * (y + 54)), (43, ))
# Coordinates for the Nose
NoseX = np.array([.18 * rmax, 0, -.18 * rmax])
NoseY = np.array([rmax - 0.004, rmax * 1.15, rmax - 0.004])
# Combine to one
X = np.concatenate((EarX2, HeadX1, NoseX, HeadX2, EarX1, HeadX3))
Y = np.concatenate((EarY2, HeadY1, NoseY, HeadY2, EarY1, HeadY3))
X *= 2 * scale
Y *= 2 * scale
X += shift[0]
Y += shift[1]
return plt.plot(X, Y, color=color, linewidth=linewidth)
def mktile(w, h):
tile = fromfunction(f, (w, h))
tile = tile.astype(int)
tile[tile > tile_max] = tile_max
return list(tile.flatten())
def from_function(cls, func, length, dtype=np.float):
return np.fromfunction(func, shape=(length, ), dtype=dtype).view(cls)
f = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.complex)
print(f)
print((np.typeDict["d"]))
print((np.typeDict["double"]))
print((np.typeDict["float64"]))
print((set(np.typeDict.values())))
print((np.arange(0, 1, 0.1)))
print((np.linspace(0, 1, 12)))
print((np.logspace(0, 2, 20)))
s = "abcdefgh"
print((np.fromstring(s, dtype=np.int16)))
print((np.fromstring(s, dtype=np.float)))
def func(i):
return i % 4 + 1
print((np.fromfunction(func, (10, ))))
def func2(i, j):
return (i + 1) * (j + 1)
print((np.fromfunction(func2, (9, 9))))
def exer6(odir):
""" Coronagraph train, no optimization for speed.
2nd order BLC, didactic example, fftlike """
# instantiate an mft object:
ft = matrixDFT.MatrixFourierTransform()
npup = 250 # Size of all arrays
radius = 50.0
# Numerical reselts in DFT setup cf telescope reselts:
# reselts of telescope - here its 0.4 reselts per DFT output image pixel if npup=250,radius=50.
dftpixel = 2.0 * radius / npup
# Jinc first zero in reselts of telescope...
firstzero_optical_reselts = 10.0
firstzero_numericalpixels = firstzero_optical_reselts / dftpixel
print("Jinc firstzero_numericalpixels", firstzero_numericalpixels)
jinc = np.fromfunction(utils.Jinc, (npup,npup),
c=utils.centerpoint(npup),
scale=firstzero_numericalpixels)
fpm_blc2ndorder = 1 - jinc*jinc
print("Jinc fpm min = ", fpm_blc2ndorder.min(),
"Jinc fpm max = ", fpm_blc2ndorder.max())
# Pupil, Pupilphase, Apodizer, FP intensity, Intensity after FPM,
# Lyot intensity, Lyot Stop, Post-Lyot Stop Intensity, Final image.
#
# Set up optical train for a typical Lyot style or phase mask coronagraph:
Cordict = {
"Pupil": utils.makedisk(npup, radius=radius),
"Pupilphase": None,
"Apodizer": None,
"FPintensity": None,
"FPM": fpm_blc2ndorder,
"LyotIntensity": None,
"LyotStop": utils.makedisk(npup, radius=41),
"PostLyotStopIntensity": None,
"FinalImage": None,
"ContrastImage": None}
# Propagate through the coronagraph train...
# Start with perfect incoming plane wave, no aberrations
efield = Cordict["Pupil"]
# Put in phase aberrations:
if Cordict["Pupilphase"] is not None:
efield *= np.exp(1j*Cordict["Pupilphase"])
# Apodize the entrance pupil:
if Cordict["Apodizer"] is not None:
efield *= Cordict["Apodizer"]
# PROPAGATE TO FIRST FOCAL PLANE:
efield = ft.perform(efield, npup, npup)
# Store FPM intensity:
Cordict["FPintensity"] = (efield * efield.conj()).real
# Save no-Cor efield for normalization of cor image by peak of no-FPM image
efield_NC = efield.copy()
# Multiply by FPM transmission function
# Lyot style - zero in center, phase mask style: zero integral over domain
efield *= Cordict["FPM"]
# PROPAGATE TO LYOT PLANE:
efield_NC = ft.perform(efield_NC, npup, npup)
efield = ft.perform(efield, npup, npup)
# Save Cor Lyot intensity;
Cordict["LyotIntensity"] = (efield * efield.conj()).real
# Apply Lyot stop:
if Cordict["LyotStop"] is not None: efield_NC *= Cordict["LyotStop"]
if Cordict["LyotStop"] is not None: efield *= Cordict["LyotStop"]
# Save Cor Lyot intensity after applying Lyot stop;
Cordict["PostLyotStopIntensity"] = (efield * efield.conj()).real
# PROPAGATE TO FINAL IMAGE PLANE:
efield_NC = ft.perform(efield_NC, npup, npup)
efield = ft.perform(efield, npup, npup)
final_image_intensity_NC = (efield_NC * efield_NC.conj()).real
final_image_intensity = (efield * efield.conj()).real
Cordict["FinalImage"] = (efield * efield.conj()).real
Cordict["ContrastImage"] = (efield * efield.conj()).real / final_image_intensity_NC.max()
# Write our coronagraph planes:
planenames, cube = corcube(Cordict)
# write planemames as fits keywords
print(odir+"/ex6_BLC_2ndOrder.fits")
fits.PrimaryHDU(cube).writeto(odir+"/ex6_BLC_2ndOrder.fits", overwrite=True)
fobj = fits.open(odir+"/ex6_BLC_2ndOrder.fits")
fobj[0].header["Pupil"] = 1
fobj[0].header["FPI"] = (2, "focal plane Intensity")
fobj[0].header["FPM"] = (3, "focal plane mask")
fobj[0].header["LyotIntn"] = (4, "Lyot Intensity")
fobj[0].header["LyotStop"] = 5
fobj[0].header["PostLyot"] = (6, "Post Lyot Stop Intensity")
fobj[0].header["CorIm"] = (7, "Raw cor image")
fobj[0].header["Contrast"] = (8, "Cor image in contrast units")
fobj.writeto(odir+"/ex6_BLC_2ndOrder.fits", overwrite=True)
def main():
# ********************************************************************
# read and test input parameters
# ********************************************************************
print('Parallel Research Kernels version ') #, PRKVERSION
print('Python Numpy Matrix transpose: B = A^T')
if len(sys.argv) != 3:
print('argument count = ', len(sys.argv))
sys.exit("Usage: ./transpose <# iterations> <matrix order>")
iterations = int(sys.argv[1])
if iterations < 1:
sys.exit("ERROR: iterations must be >= 1")
order = int(sys.argv[2])
if order < 1:
sys.exit("ERROR: order must be >= 1")
print('Number of iterations = ', iterations)
print('Matrix order = ', order)
# ********************************************************************
# ** Allocate space for the input and transpose matrix
# ********************************************************************
A = numpy.fromfunction(lambda i, j: i * order + j, (order, order),
dtype=float)
B = numpy.zeros((order, order))
for k in range(0, iterations + 1):
if k < 1: t0 = timer()
transpose(order, A, B)
add(order, A, 1.0)
#kernel(order,A,B)
t1 = timer()
trans_time = t1 - t0
# ********************************************************************
# ** Analyze and output results.
# ********************************************************************
A = numpy.fromfunction(lambda i, j: ((iterations / 2.0) +
(order * j + i)) * (iterations + 1.0),
(order, order),
dtype=float)
abserr = numpy.linalg.norm(numpy.reshape(B - A, order * order), ord=1)
epsilon = 1.e-8
nbytes = 2 * order**2 * 8 # 8 is not sizeof(double) in bytes, but allows for comparison to C etc.
if abserr < epsilon:
print('Solution validates')
avgtime = trans_time / iterations
print('Rate (MB/s): ', 1.e-6 * nbytes / avgtime, ' Avg time (s): ',
avgtime)
else:
print('error ', abserr, ' exceeds threshold ', epsilon)
sys.exit("ERROR: solution did not validate")
count+=trix[i,j]
if (count>inf):
inf = count
return inf
def infinite(trix):
shape = trix.shape
row = shape[0]
col = shape[1]
first = 0
for i in range(col):
count = 0
for j in range(row):
count+=trix[j,i]
if(count>first):
first = count
return first
A = np.fromfunction(lambda x,y : 2*x+y, (4,5))
B = A.transpose()
C = A.dot(B)
#print(A)
#print(B)
#print(C)
print()
print(' Frobenious for C: {0:10.5f} Norm: {1:10.5f} Infinite: {2:10.5f}'.format(froben(C),norm(C),infinite(C)))
matrix = np.fromfunction(lambda x,y : 2*x+y, (1000,1000))
print('Frobenious for Matrix: {0:10.5f} Norm: {1:10.5f} Infinite: {2:10.5f}'.format(froben(matrix),norm(matrix),infinite(matrix)))
print()
print('Code Run Time:',clock.time() - start)
