I am trying to fit a gaussian. I tried to fit using OriginPro and Python. The fit in OriginPro is better than that obtained through Python and I would like to do it using Python.
OriginPro:
Python:
The code I used is:
import numpy as np
import matplotlib.pyplot as plt
import lmfit
data=data
mod=lmfit.models.GaussianModel()
x=np.arange(140,510,1)
y= np.array(np.log(data[140:510]), dtype=np.float32)
idx= (np.isfinite(y))
pars = mod.guess(y[idx], x=x[idx])
out = mod.fit(y[idx], pars, x=x[idx])
plt.plot(x[idx], out.best_fit, 'r', label='Gaussian Model')
plt.plot(x,np.log(data[140:510]))
plt.show()
data:
[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 34., 33., 30.,
25., 47., 36., 37., 33., 41., 42., 40., 49., 47., 44., 35., 0.,
0., 0., 30., 32., 37., 36., 50., 40., 30., 41., 29., 33., 34.,
42., 41., 39., 43., 34., 30., 27., 48., 38., 20., 53., 38., 32.,
41., 40., 45., 39., 34., 33., 41., 32., 41., 41., 30., 42., 41.,
33., 62., 36., 47., 44., 35., 44., 36., 40., 35., 43., 38., 36.,
48., 50., 31., 46., 50., 43., 50., 40., 35., 39., 50., 47., 46.,
35., 39., 33., 49., 43., 56., 45., 56., 0., 0., 0., 0., 42.,
41., 43., 46., 40., 40., 38., 40., 39., 49., 33., 39., 57., 51.,
51., 43., 47., 55., 67., 68., 44., 48., 0., 0., 0., 0., 0.,
48., 66., 55., 60., 63., 58., 72., 53., 62., 55., 63., 64., 60.,
61., 56., 58., 71., 51., 74., 58., 69., 61., 50., 59., 66., 57.,
56., 68., 63., 53., 70., 73., 49., 65., 56., 62., 45., 55., 0.,
0., 0., 0., 66., 53., 52., 52., 61., 42., 53., 49., 81., 67.,
63., 69., 58., 80., 74., 51., 55., 65., 68., 56., 71., 58., 59.,
84., 54., 49., 46., 69., 57., 54., 74., 68., 60., 56., 51., 58.,
47., 57., 0., 0., 0., 0., 65., 47., 59., 39., 34., 57., 45.,
43., 57., 61., 39., 52., 48., 42., 53., 41., 0., 0., 0., 0.,
48., 35., 53., 44., 46., 52., 50., 51., 44., 55., 42., 58., 53.,
42., 0., 0., 0., 0., 41., 39., 47., 46., 46., 46., 41., 44.,
49., 48., 47., 43., 46., 38., 47., 39., 29., 53., 40., 45., 43.,
41., 23., 41., 39., 46., 37., 42., 24., 40., 46., 39., 37., 49.,
47., 37., 28., 36., 34., 34., 43., 41., 48., 42., 44., 45., 43.,
45., 36., 33., 48., 39., 54., 35., 30., 42., 34., 51., 39., 50.,
36., 34., 50., 37., 48., 40., 39., 21., 41., 40., 42., 44., 48.,
42., 42., 39., 43., 57., 37., 36., 38., 34., 50., 40., 30., 29.,
38., 44., 43., 47., 35., 37., 44., 44., 32., 36., 41., 44., 28.,
43., 36., 37., 34., 37., 0., 0., 0., 0., 54., 34., 45., 0.,
0., 0., 0., 0., 44., 32., 28., 34., 42., 35., 40., 45., 42.,
47., 39., 35., 52., 34., 55., 38., 1.]
Output for fit_report:
In [37]:out.fit_report()
Out[37]: "[[Model]]\n Model(gaussian)\n[[Fit Statistics]]\n # fitting method = leastsq\n # function evals = 17\n # data points = 333\n # variables = 3\n chi-square = 12.5923742\n reduced chi-square = 0.03815871\n Akaike info crit = -1084.59201\n Bayesian info crit = -1073.16758\n[[Variables]]\n amplitude: 3590.97370 +/- 125.195985 (3.49%) (init = 781.4034)\n center: 317.738344 +/- 3.57625327 (1.13%) (init = 322.4771)\n sigma: 361.440601 +/- 13.6760525 (3.78%) (init = 181.5)\n fwhm: 851.127556 +/- 32.2046420 (3.78%) == '2.3548200*sigma'\n height: 3.96355944 +/- 0.01657428 (0.42%) == '0.3989423*amplitude/max(1e-15, sigma)'\n[[Correlations]] (unreported correlations are < 0.100)\n C(amplitude, sigma) = 0.997"
Has it got something to do with the guess function I used?
Hints give in the comments seem to be insufficient. You need to include an offset in your model. A Gaussian function goes to 0 far from the peak intensity - I don't know what OriginPro is doing, but clearly, it is modeling more than a Gaussian.
Try making a model that is a Gaussian + a Constant, as with:
import numpy as np
import matplotlib.pyplot as plt
import lmfit
data = np.array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
34., 33., 30., 25., 47., 36., 37., 33., 41., 42., 40.,
49., 47., 44., 35., 0., 0., 0., 30., 32., 37., 36., 50.,
40., 30., 41., 29., 33., 34., 42., 41., 39., 43., 34.,
30., 27., 48., 38., 20., 53., 38., 32., 41., 40., 45.,
39., 34., 33., 41., 32., 41., 41., 30., 42., 41., 33.,
62., 36., 47., 44., 35., 44., 36., 40., 35., 43., 38.,
36., 48., 50., 31., 46., 50., 43., 50., 40., 35., 39.,
50., 47., 46., 35., 39., 33., 49., 43., 56., 45., 56.,
0., 0., 0., 0., 42., 41., 43., 46., 40., 40., 38., 40.,
39., 49., 33., 39., 57., 51., 51., 43., 47., 55., 67.,
68., 44., 48., 0., 0., 0., 0., 0., 48., 66., 55., 60.,
63., 58., 72., 53., 62., 55., 63., 64., 60., 61., 56.,
58., 71., 51., 74., 58., 69., 61., 50., 59., 66., 57.,
56., 68., 63., 53., 70., 73., 49., 65., 56., 62., 45.,
55., 0., 0., 0., 0., 66., 53., 52., 52., 61., 42., 53.,
49., 81., 67., 63., 69., 58., 80., 74., 51., 55., 65.,
68., 56., 71., 58., 59., 84., 54., 49., 46., 69., 57.,
54., 74., 68., 60., 56., 51., 58., 47., 57., 0., 0., 0.,
0., 65., 47., 59., 39., 34., 57., 45., 43., 57., 61.,
39., 52., 48., 42., 53., 41., 0., 0., 0., 0., 48., 35.,
53., 44., 46., 52., 50., 51., 44., 55., 42., 58., 53.,
42., 0., 0., 0., 0., 41., 39., 47., 46., 46., 46., 41.,
44., 49., 48., 47., 43., 46., 38., 47., 39., 29., 53.,
40., 45., 43., 41., 23., 41., 39., 46., 37., 42., 24.,
40., 46., 39., 37., 49., 47., 37., 28., 36., 34., 34.,
43., 41., 48., 42., 44., 45., 43., 45., 36., 33., 48.,
39., 54., 35., 30., 42., 34., 51., 39., 50., 36., 34.,
50., 37., 48., 40., 39., 21., 41., 40., 42., 44., 48.,
42., 42., 39., 43., 57., 37., 36., 38., 34., 50., 40.,
30., 29., 38., 44., 43., 47., 35., 37., 44., 44., 32.,
36., 41., 44., 28., 43., 36., 37., 34., 37., 0., 0., 0.,
0., 54., 34., 45., 0., 0., 0., 0., 0., 44., 32., 28.,
34., 42., 35., 40., 45., 42., 47., 39., 35., 52., 34.,
55., 38., 1.])
data = data[140:510]
ipos = np.where(data>0)[0]
data = np.log(data[ipos])
x = np.arange(140,510,1.0)[ipos]
mod = lmfit.models.GaussianModel() + lmfit.models.ConstantModel()
pars = mod.make_params(c=data.mean(),
center=x.mean(),
sigma=x.std(),
amplitude=x.std()*data.ptp())
out = mod.fit(data, pars, x=x)
print(out.fit_report())
plt.plot(x, out.best_fit, 'r', label='Gaussian Model')
plt.plot(x, data)
plt.show()
This will print a report of
[Model]]
(Model(gaussian) + Model(constant))
[[Fit Statistics]]
# fitting method = leastsq
# function evals = 48
# data points = 333
# variables = 4
chi-square = 9.50683177
reduced chi-square = 0.02889615
Akaike info crit = -1176.19189
Bayesian info crit = -1160.95932
[[Variables]]
amplitude: 58.7086539 +/- 5.27950257 (8.99%) (init = 153.376)
center: 302.462920 +/- 2.79518589 (0.92%) (init = 322.6336)
sigma: 48.1997878 +/- 3.66967747 (7.61%) (init = 106.8759)
c: 3.64131210 +/- 0.01679060 (0.46%) (init = 3.796494)
fwhm: 113.501824 +/- 8.64142989 (7.61%) == '2.3548200*sigma'
height: 0.48592258 +/- 0.02641186 (5.44%) == '0.3989423*amplitude/max(1e-15, sigma)'
[[Correlations]] (unreported correlations are < 0.100)
C(amplitude, c) = -0.832
C(amplitude, sigma) = 0.798
C(sigma, c) = -0.664
and a plot of
Related
I'm struggling with the result of a matrix multiplication in pytorch and I don't know how to solve it, in particular:
I'm multiplying these two matrices
tensor([[[[209.5000, 222.7500],
[276.5000, 289.7500]],
[[208.5000, 221.7500],
[275.5000, 288.7500]]]], dtype=torch.float64)
and
tensor([[[[ 0., 1., 2., 5., 6., 7., 10., 11., 12.],
[ 2., 3., 4., 7., 8., 9., 12., 13., 14.],
[10., 11., 12., 15., 16., 17., 20., 21., 22.],
[12., 13., 14., 17., 18., 19., 22., 23., 24.]],
[[25., 26., 27., 30., 31., 32., 35., 36., 37.],
[27., 28., 29., 32., 33., 34., 37., 38., 39.],
[35., 36., 37., 40., 41., 42., 45., 46., 47.],
[37., 38., 39., 42., 43., 44., 47., 48., 49.]],
[[50., 51., 52., 55., 56., 57., 60., 61., 62.],
[52., 53., 54., 57., 58., 59., 62., 63., 64.],
[60., 61., 62., 65., 66., 67., 70., 71., 72.],
[62., 63., 64., 67., 68., 69., 72., 73., 74.]]]],
dtype=torch.float64)
with the following line of code A.view(2,-1) # B, and then I reshape the result with result.view(2, 3, 3, 3).
The resulting matrix is
tensor([[[[ 6687.5000, 7686.0000, 8684.5000],
[11680.0000, 12678.5000, 13677.0000],
[16672.5000, 17671.0000, 18669.5000]],
[[ 6663.5000, 7658.0000, 8652.5000],
[11636.0000, 12630.5000, 13625.0000],
[16608.5000, 17603.0000, 18597.5000]],
[[31650.0000, 32648.5000, 33647.0000],
[36642.5000, 37641.0000, 38639.5000],
[41635.0000, 42633.5000, 43632.0000]]],
[[[31526.0000, 32520.5000, 33515.0000],
[36498.5000, 37493.0000, 38487.5000],
[41471.0000, 42465.5000, 43460.0000]],
[[56612.5000, 57611.0000, 58609.5000],
[61605.0000, 62603.5000, 63602.0000],
[66597.5000, 67596.0000, 68594.5000]],
[[56388.5000, 57383.0000, 58377.5000],
[61361.0000, 62355.5000, 63350.0000],
[66333.5000, 67328.0000, 68322.5000]]]], dtype=torch.float64)
Instead I want
tensor([[[[ 6687.5000, 7686.0000, 8684.5000],
[11680.0000, 12678.5000, 13677.0000],
[16672.5000, 17671.0000, 18669.5000]],
[[31650.0000, 32648.5000, 33647.0000],
[36642.5000, 37641.0000, 38639.5000],
[41635.0000, 42633.5000, 43632.0000]],
[[56612.5000, 57611.0000, 58609.5000],
[61605.0000, 62603.5000, 63602.0000],
[66597.5000, 67596.0000, 68594.5000]]],
[[[ 6663.5000, 7658.0000, 8652.5000],
[11636.0000, 12630.5000, 13625.0000],
[16608.5000, 17603.0000, 18597.5000]],
[[31526.0000, 32520.5000, 33515.0000],
[36498.5000, 37493.0000, 38487.5000],
[41471.0000, 42465.5000, 43460.0000]],
[[56388.5000, 57383.0000, 58377.5000],
[61361.0000, 62355.5000, 63350.0000],
[66333.5000, 67328.0000, 68322.5000]]]], dtype=torch.float64)
Can someone help me? Thanks
This is a common but interesting problem because it involves a combination of torch.reshapes and torch.transpose to solve it. More specifically, you will need
Apply an initial reshape to restructure the tensor and expose the axes you want to swap;
Then do so using a transpose operation;
Lastly apply a second reshape to get to the desired format.
In your case, you could do:
>>> result.reshape(3,2,3,3).transpose(0,1).reshape(2,3,3,3)
tensor([[[[ 6687.5000, 7686.0000, 8684.5000],
[11680.0000, 12678.5000, 13677.0000],
[16672.5000, 17671.0000, 18669.5000]],
[[31650.0000, 32648.5000, 33647.0000],
[36642.5000, 37641.0000, 38639.5000],
[41635.0000, 42633.5000, 43632.0000]],
[[56612.5000, 57611.0000, 58609.5000],
[61605.0000, 62603.5000, 63602.0000],
[66597.5000, 67596.0000, 68594.5000]]],
[[[ 6663.5000, 7658.0000, 8652.5000],
[11636.0000, 12630.5000, 13625.0000],
[16608.5000, 17603.0000, 18597.5000]],
[[31526.0000, 32520.5000, 33515.0000],
[36498.5000, 37493.0000, 38487.5000],
[41471.0000, 42465.5000, 43460.0000]],
[[56388.5000, 57383.0000, 58377.5000],
[61361.0000, 62355.5000, 63350.0000],
[66333.5000, 67328.0000, 68322.5000]]]], dtype=torch.float64)
I encourage you to look a the intermediate results to get an idea of how the method works so you can apply it on other use cases in the future.
I'm trying to put a small 8x7 2D array, inside an 8x8 2D array.
Here's what I'm working with:
--> Array called 'a' with shape 8x7
a = [[ 16., 11., 10., 16., 24., 40., 51.],
[ 12., 12., 14., 19., 26., 58., 60.],
[ 14., 13., 16., 24., 40., 57., 69.],
[ 14., 17., 22., 29., 51., 87., 80.],
[ 18., 22., 37., 56., 68., 109., 103.],
[ 24., 35., 55., 64., 81., 104., 113.],
[ 49., 64., 78., 87., 103., 121., 120.],
[ 72., 92., 95., 98., 112., 100., 103.]]
--> Array called 'b' with shape 8x8
b = [[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.]]
So basically, what I want is:
--> Array called 'c' with shape 8x8
c = [[ 16., 11., 10., 16., 24., 40., 51., 0],
[ 12., 12., 14., 19., 26., 58., 60., 0],
[ 14., 13., 16., 24., 40., 57., 69., 0],
[ 14., 17., 22., 29., 51., 87., 80., 0],
[ 18., 22., 37., 56., 68., 109., 103., 0],
[ 24., 35., 55., 64., 81., 104., 113., 0],
[ 49., 64., 78., 87., 103., 121., 120., 0],
[ 72., 92., 95., 98., 112., 100., 103., 0]]
Is there an easy way to do this, preferably without using loops, like 'for' , 'while', 'map'
or list comprehension?
Thank you in advance!
You can just slice assign to b up to the dimensions of a:
x, y = a.shape
b[:x, :y] = a
print(b)
array([[ 16., 11., 10., 16., 24., 40., 51., 0.],
[ 12., 12., 14., 19., 26., 58., 60., 0.],
[ 14., 13., 16., 24., 40., 57., 69., 0.],
[ 14., 17., 22., 29., 51., 87., 80., 0.],
[ 18., 22., 37., 56., 68., 109., 103., 0.],
[ 24., 35., 55., 64., 81., 104., 113., 0.],
[ 49., 64., 78., 87., 103., 121., 120., 0.],
[ 72., 92., 95., 98., 112., 100., 103., 0.]])
I am trying to find the first minimum after the first peak in a data array. Here is my code:
x = array
mins = argrelextrema(x, np.less)[0]
mins_above_zero = np.where(x[mins] > 0)[0]
ag = x[mins[mins_above_zero]].argmin()
true_minimum_index = mins[ag]
pyplot.scatter(mins, x[mins])
pyplot.plot(x)
pyplot.ylim(0, 2000)
It currently picks out too many minimums.
If I have a numpy array like this:
array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 1., 0., 1., 0.,
0., 0., 1., 1., 0., 0., 2., 0., 2., 1., 3.,
1., 2., 5., 8., 6., 55., 396., 608., 157., 40., 45.,
43., 51., 74., 89., 107., 121., 98., 111., 122., 170., 187.,
190., 229., 284., 372., 450., 457., 327., 328., 318., 288., 290.,
262., 235., 223., 177., 232., 217., 234., 261., 206., 192., 221.,
189., 181., 185., 162., 140., 144., 171., 176., 168., 213., 222.,
314., 397., 413., 429., 442., 352., 416., 439., 424., 480., 479.,
515., 522., 569., 543., 626., 666., 637., 680., 678., 747., 720.,
695., 674., 605., 490., 475., 332., 284., 252., 169., 140., 117.,
86., 71., 58., 55., 37., 45., 35., 25., 21., 16., 14.,
17., 12., 9., 7., 6., 0., 6., 6., 6., 3., 1.,
1., 4., 2., 1., 4., 0., 2., 2., 0., 1., 2.,
0., 0., 4., 0., 1., 1., 0., 0., 0., 0., 0.,
0., 1., 1., 0.])
That creates a plot like this except just with the minimum after the first peak:
Try playing with the order of argrelextrema
With your array data:
x = array
# Order 2 looks at more than just the immediate numbers around a variable
mins = argrelextrema(x, np.less, order=2)[0]
print(mins)
mins_above_zero = np.where(x[mins] > 0)[0]
ag = x[mins[mins_above_zero]].argmin()
true_minimum_index = mins[ag]
#Grabs the first relative minimum
mins = mins[0]
pyplot.scatter(mins, x[mins])
pyplot.plot(x)
pyplot.ylim(0, 2000)
Which creates:
I have an numpy array data of shape (3, 3, k), where the length k is fixed.
The array was processed to a flatten one dimensional one with:
mat2 = numpy.transpose(data, (1, 0, 2)).flatten('C')
How do I reverse this transpose / flattening process to get the original (3, 3, k) shape and ordering of the data array?
>>> k = 10
# Generating a `(3, 3, k)` matrix:
>>> a = np.linspace(0, 89, 90).reshape((3, 3, k))
array([[[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.],
[10., 11., 12., 13., 14., 15., 16., 17., 18., 19.],
[20., 21., 22., 23., 24., 25., 26., 27., 28., 29.]],
[[30., 31., 32., 33., 34., 35., 36., 37., 38., 39.],
[40., 41., 42., 43., 44., 45., 46., 47., 48., 49.],
[50., 51., 52., 53., 54., 55., 56., 57., 58., 59.]],
[[60., 61., 62., 63., 64., 65., 66., 67., 68., 69.],
[70., 71., 72., 73., 74., 75., 76., 77., 78., 79.],
[80., 81., 82., 83., 84., 85., 86., 87., 88., 89.]]])
# Doing your transform on it:
>>> b = np.transpose(a, (1, 0, 2)).flatten('C')
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 30., 31., 32.,
33., 34., 35., 36., 37., 38., 39., 60., 61., 62., 63., 64., 65.,
66., 67., 68., 69., 10., 11., 12., 13., 14., 15., 16., 17., 18.,
19., 40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 70., 71.,
72., 73., 74., 75., 76., 77., 78., 79., 20., 21., 22., 23., 24.,
25., 26., 27., 28., 29., 50., 51., 52., 53., 54., 55., 56., 57.,
58., 59., 80., 81., 82., 83., 84., 85., 86., 87., 88., 89.])
# Reversing the transform:
>>> c = b.reshape((3, 3, k)).transpose((1, 0, 2))
array([[[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.],
[10., 11., 12., 13., 14., 15., 16., 17., 18., 19.],
[20., 21., 22., 23., 24., 25., 26., 27., 28., 29.]],
[[30., 31., 32., 33., 34., 35., 36., 37., 38., 39.],
[40., 41., 42., 43., 44., 45., 46., 47., 48., 49.],
[50., 51., 52., 53., 54., 55., 56., 57., 58., 59.]],
[[60., 61., 62., 63., 64., 65., 66., 67., 68., 69.],
[70., 71., 72., 73., 74., 75., 76., 77., 78., 79.],
[80., 81., 82., 83., 84., 85., 86., 87., 88., 89.]]])
# Figuring out if we did it right:
>>> np.array_equal(a, c)
True
I'm trying to perform a fourier transform of a data set that I have and subsequently writing its real and imaginary parts separately.
This is my code:
import sys,string
import numpy as np
from math import *
import fileinput
from scipy.fftpack import fft, ifft
temparray = []
for i in range(200000):
line = sys.stdin.readline() ## reads data from a text file
fields = map(float,line.split())
temparray.append(fields)
acf = sum(temparray,[]) ## I need to do this as the appended array from above is nested
y = np.fft.fft(acf)
z = (y.real,y.imag)
print z
The output that I get is as follows:
(array([ 2600.36368107, 2439.50426935, 1617.52631545, ..., 1575.78483016, 1617.52631545, 2439.50426935]), array([ 0. , -767.19967198, -743.75183367, ..., 726.45052092, 743.75183367, 767.19967198]))
It looks like its only printing the first few and last few values, completely skipping everything in between. Can anybody please tell me why this is happening?
Thanks
As others have indicated, include a modified version of
>>> np.set_printoptions(edgeitems=5,linewidth=80,precision=2,suppress=True,threshold=10)
>>> a = np.arange(0,100.)
>>>
>>> a
array([ 0., 1., 2., 3., 4., ..., 95., 96., 97., 98., 99.])
>>> np.set_printoptions(edgeitems=5,linewidth=80,precision=2,suppress=True,threshold=100)
>>> a
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.,
12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23.,
24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35.,
36., 37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47.,
48., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71.,
72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83.,
84., 85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95.,
96., 97., 98., 99.])
np.set_printoptions(edgeitems=3,linewidth=80,precision=2,suppress=True,threshold=5)
perhaps setting threshold to some very large number.
Addendum
I would be remiss if I didn't state that the simplest solution to the above is to simple use
>>> list(a)
should you not care whether an array is visually returned or not.