Mailman 3 February 2009 - SciPy-User

Help required regding Eigenvectors
by Sudheer Phani 14 Mar '22

14 Mar '22

Hello All, I have been encountering some strange problems with the calculation of eigen vectors using python. The problem is with the sign of the eigen vectors calculated. On Very few occasions the eigen vectors calculated using python have an opposite sign than the actual eigenvectors, though the magnitude is correct. Can any one of you plz help me in this regard and suggest me some solution if you have encoutered similar problems . Any help in this regd is appreciated Thanks in Advace regds Sudheer

5 5

pupynere/scipy.io.netcdf
by Ryan May 06 Mar '13

06 Mar '13

Hi, Anyone know if pupynere (a version of which is in scipy.io.netcdf) supports writing files with 64-bit offsets? This allows writing files larger than 2GB. Ryan -- Ryan May Graduate Research Assistant School of Meteorology University of Oklahoma

7 6

scipy/numpy on CentOS 5/ Dependency problem
by Matthias Blaicher 09 Dec '10

09 Dec '10

Hello, I want to install SciPy and numpy on a CentOS 5 system. It contains a fresh install with up-to-date packages. I use the "official" Suse Build repos by DavidCournapeau. It fails with a conflict between refblas3 and blas. [root@localhost yum.repos.d]# yum install python-numpy python-scipy Loading "fastestmirror" plugin Loading mirror speeds from cached hostfile * home_ashigabou: download.opensuse.org * extras: mirrors.tummy.com * updates: dds.gina.alaska.edu * base: mirror.hmc.edu * addons: mirrors.tummy.com extras 100% |=========================| 1.1 kB 00:00 updates 100% |=========================| 951 B 00:00 base 100% |=========================| 1.1 kB 00:00 addons 100% |=========================| 951 B 00:00 Setting up Install Process Parsing package install arguments Resolving Dependencies --> Running transaction check ---> Package python-scipy.i386 0:0.6.0-2.1 set to be updated --> Processing Dependency: libblas.so.3 for package: python-scipy --> Processing Dependency: libblas.so.3 for package: python-scipy --> Processing Dependency: liblapack.so.3 for package: python-scipy --> Processing Dependency: libgfortran.so.1 for package: python-scipy --> Processing Dependency: liblapack.so.3 for package: python-scipy ---> Package python-numpy.i386 0:1.2.0-1.1 set to be updated --> Processing Dependency: gcc-gfortran for package: python-numpy --> Processing Dependency: refblas3 for package: python-numpy --> Processing Dependency: lapack3 < 3.1 for package: python-numpy --> Running transaction check ---> Package gcc-gfortran.i386 0:4.1.2-42.el5 set to be updated --> Processing Dependency: gcc = 4.1.2-42.el5 for package: gcc-gfortran ---> Package blas.i386 0:3.0-37.el5 set to be updated ---> Package lapack3.i386 0:3.0-19.1 set to be updated ---> Package lapack.i386 0:3.0-37.el5 set to be updated ---> Package refblas3.i386 0:3.0-11.1 set to be updated ---> Package libgfortran.i386 0:4.1.2-42.el5 set to be updated --> Running transaction check ---> Package gcc.i386 0:4.1.2-42.el5 set to be updated --> Processing Dependency: libgomp.so.1 for package: gcc --> Processing Dependency: glibc-devel >= 2.2.90-12 for package: gcc --> Processing Dependency: libgomp = 4.1.2-42.el5 for package: gcc --> Running transaction check ---> Package glibc-devel.i386 0:2.5-24 set to be updated --> Processing Dependency: glibc-headers for package: glibc-devel --> Processing Dependency: glibc-headers = 2.5-24 for package: glibc-devel ---> Package libgomp.i386 0:4.1.2-42.el5 set to be updated --> Running transaction check ---> Package glibc-headers.i386 0:2.5-24 set to be updated --> Processing Dependency: kernel-headers for package: glibc-headers --> Processing Dependency: kernel-headers >= 2.2.1 for package: glibc-headers --> Running transaction check ---> Package kernel-headers.i386 0:2.6.18-92.1.13.el5 set to be updated --> Processing Conflict: refblas3 conflicts blas --> Finished Dependency Resolution Error: refblas3 conflicts with blas Is there anything I'm doing wrong here, as I don't want to compile all dependencies by myself.. Sincerly, Matthias Blaicher

3 2

3D plotting
by Robert Cimrman 11 Sep '09

11 Sep '09

Hi, I need to do some simple 3D plots, so I tried the two Cookbook recipes (xplt, mplot3d) and failed: * xplt: does not work when using a custom installation directory such as python setup.py install --root=/home/share/software apparently the gistdata directory path is wrong: gist.error: failed to create drawing -- Gist work.gs style sheet missing * mplot3d: does not work with my version of matplotlib (0.80). I have made the changes mentioned in the Cookbook to no avail. (Axes.__init__() args apparently changed, as well as some other matplotlib object attributes) Any ideas? mplot3d looks great, I would really like to use it! thanks, r.

6 6

assign to diagonal values?
by Carlos Scheidegger 07 Jul '09

07 Jul '09

Say I have a matrix m whose diagonal values I want to replace with the contents of vector new_diagonal. Right now, I'm using m -= diag(m) m += diag(new_diagonal) but that seems pretty wasteful (especially if diag() creates new arrays, which I suspect it does). Is there a standard (or any efficient) way to assign the diagonal values directly without an explicit for loop? Googling for "site:www.scipy.org assign diagonal" only returned results for sparse matrices, which is not the case here - these are plain numpy arrays. Thanks in advance, -carlos

11 17

Is numpy's argsort lying about its numpy.int32 types?
by Rob Clewley 15 May '09

15 May '09

Hi, I'm having a problem comparing some types when using numpy's argsort. I'm using numpy 1.0.2. I can reproduce it simply: Python 2.4.4 (#71, Oct 18 2006, 08:34:43) [MSC v.1310 32 bit (Intel)] << snip >> In [1]: from numpy import argsort, sort, int32, array In [2]: x=array([1,3,2]) In [3]: aa=argsort(x) In [4]: as=sort(x) In [5]: type(aa[0]) Out[5]: <type 'numpy.int32'> In [6]: type(as[0]) Out[6]: <type 'numpy.int32'> In [7]: int32 Out[7]: <type 'numpy.int32'> In [8]: type(as[0])==int32 Out[8]: True In [9]: type(aa[0])==int32 Out[9]: False Any of the three indices in aa give me the same problem. Can someone explain if I should be doing this a different way, and if this is a bug?! Thanks, Rob

5 6

Automating Matlab
by Eric Schug 28 Apr '09

28 Apr '09

Is there strong interest in automating matlab to numpy conversion? I have a working version of a matlab to python translator. It allows translation of matlab scripts into numpy constructs, supporting most of the matlab language. The parser is nearly complete. Most of the remaining work involves providing a robust translation. Such as * making sure that copies on assign are done when needed. * correct indexing a(:) becomes a.flatten(1) when on the left hand side (lhs) of equals and a[:] when on the right hand side I've seen a few projects attempt to do this, but for one reason or another have stopped it.

16 22

cdf and integration for multivariate normal distribution in stats.kde
by josef.pktd＠gmail.com 06 Apr '09

06 Apr '09

I found the fortran code for rectangular integration of the multivariate normal distribution in stats kde, which can be used to calculate the cdf. I didn't see this function exposed anywhere in scipy. Did I miss it? I wrote a quick wrapper, with two functions mvstdnormcdf(lower,upper,corrcoef, **kwds) direct convenience wrapper with just some reparameterization for convenience, for standard normal mvnormcdf(lower, upper, mu, cov, **kwds) allows non-standard multivariate normal distribution, normalizes distribution and calls mvstdnormcdf Both calculate the integral only for a single are, no vectorization yet. Also, this is not yet a clean version. I wanted to ask first if I missed it, and it's already used somewhere in scipy. Josef

5 9

reverse an array
by Williamson, Ross 02 Mar '09

02 Mar '09

Hi everyone Is there an easy way to reverse an array without converting it to a list? i.e I'm currently doing: x = array([0,1,2,3,4]) x = x.tolist() x.reverse() x = array(x) print x : [4,3,2,1,0] Thanks Ross

3 2

Some more useful image filters: anisotropic diffusion and Canny edge-finding
by Zachary Pincus 28 Feb '09

28 Feb '09

Hi all, As I've been quite happily using with Nadav's bilateral filtering code, I figured I should reciprocate and post some other useful basic image-processing algorithms that I've recently numpy-ified. Here are first-passes at Canny edge finding and Perona and Malik-style anisotropic diffusion; both are pretty simplistic and not particularly fast, but they work as advertised. Zach import numpy import scipy.ndimage as ndimage # Anisotropic Diffusion, as per Perona and Malik's paper (see section V). def _exp(image_gradient, scale): return numpy.exp(-(numpy.absolute(image_gradient)/scale)**2) def _inv(image_gradient, scale): return 1 / (1 + (numpy.absolute(image_gradient)/scale)**2) def anisotropic_diffusion(image, num_iters=10, scale=10, step_size=0.2, conduction_function=_inv): # 'step_size' is Perona and Malik's lambda parameter; scale is their 'K' parameter. # The 'conduction_function' is the function 'g' in the original formulation; # if this function simply returns a constant, the result is Gaussian blurring. if step_size > 0.25: raise ValueError('step_size parameter must be <= 0.25 for numerical stability.') image = image.copy() # simplistic boundary conditions -- no diffusion at the boundary central = image[1:-1, 1:-1] n = image[:-2, 1:-1] s = image[2:, 1:-1] e = image[1:-1, :-2] w = image[1:-1, 2:] directions = [s,e,w] for i in range(num_iters): di = n - central accumulator = conduction_function(di, scale)*di for direction in directions: di = direction - central accumulator += conduction_function(di, scale)*di accumulator *= step_size central += accumulator return image # Canny edge-finding, implemented as per the Wikipedia article # Note that this takes four passes through the image to do the # non-maximal suppression, whereas a c or cython loop could do # it in one. # Filter kernels for calculating the value of neighbors in several directions _N = numpy.array([[0, 1, 0], [0, 0, 0], [0, 1, 0]], dtype=bool) _NE = numpy.array([[0, 0, 1], [0, 0, 0], [1, 0, 0]], dtype=bool) _W = numpy.array([[0, 0, 0], [1, 0, 1], [0, 0, 0]], dtype=bool) _NW = numpy.array([[1, 0, 0], [0, 0, 0], [0, 0, 1]], dtype=bool) # After quantizing the angles, vertical (north-south) edges get values of 3, # northwest-southeast edges get values of 2, and so on, as below: _NE_d = 0 _W_d = 1 _NW_d = 2 _N_d = 3 def canny(image, high_threshold, low_threshold): grad_x = ndimage.sobel(image, 0) grad_y = ndimage.sobel(image, 1) grad_mag = numpy.sqrt(grad_x**2+grad_y**2) grad_angle = numpy.arctan2(grad_y, grad_x) # next, scale the angles in the range [0, 3] and then round to quantize quantized_angle = numpy.around(3 * (grad_angle + numpy.pi) / (numpy.pi * 2)) # Non-maximal suppression: an edge pixel is only good if its magnitude is # greater than its neighbors normal to the edge direction. We quantize # edge direction into four angles, so we only need to look at four # sets of neighbors NE = ndimage.maximum_filter(grad_mag, footprint=_NE) W = ndimage.maximum_filter(grad_mag, footprint=_W) NW = ndimage.maximum_filter(grad_mag, footprint=_NW) N = ndimage.maximum_filter(grad_mag, footprint=_N) thinned = (((g > W) & (quantized_angle == _N_d )) | ((g > N) & (quantized_angle == _W_d )) | ((g > NW) & (quantized_angle == _NE_d)) | ((g > NE) & (quantized_angle == _NW_d)) ) thinned_grad = thinned * grad_mag # Now, hysteresis thresholding: find seeds above a high threshold, then # expand out until we go below the low threshold high = thinned_grad > high_threshold low = thinned_grad > low_threshold canny_edges = ndimage.binary_dilation(high, iterations=-1, mask=low) return grad_mag, thinned_grad, canny_edges

1 2