gmane.comp.python.scientific.user

Re: griddata not working after update to Python 2.7

Pauli Virtanen — 2012-05-24T18:09:20

24.05.2012 15:50, Umut Yildiz kirjoitti:
[clip]
[clip]

Note that this is the griddata function from matplotlib, so asking on
one of the Matplotlib lists could be useful.

Re: subclassing ndarray : i want slice to return > ndarray, not subclass

Tom Aldcroft — 2012-05-24T16:09:42

After seeing this thread I brought this point up on the
numpy-discussion list.  Here is a link to the thread:

http://mail.scipy.org/pipermail/numpy-discussion/2012-May/062451.html

- Tom

griddata not working after update to Python 2.7

Umut Yildiz — 2012-05-24T13:50:52

Dear All,

I used to use griddata in order to make my contourmaps. However, after I updated
my Python from 2.6 to 2.7 griddata is not working anymore.

I tried some workarounds but no success.

The countourmap that I produced before is here.
http://dl.dropbox.com/u/17983476/matplotlib/contour_dT_workingbefore.png

After the Python 2.7 update, it turns to the following.
http://dl.dropbox.com/u/17983476/matplotlib/contour_dT_broken.png

Here is the datafile.
http://dl.dropbox.com/u/17983476/matplotlib/contour_dT.dat

And the associated python script (which is also below).
http://dl.dropbox.com/u/17983476/matplotlib/contour_dT.py

The code that I was using before is here. I had to comment out #import griddata
line because this is the only way that it continues. Is this a bug in griddata,
or if there are new workarounds, I would be glad to know a new method to produce
my contourplots again.

Thanks a lot

----------------------------
#! /usr/bin python

import os
import sys
import math
from math import *
from nu

Some numpy funcs for PyPy

Dmitrey — 2012-05-24T11:32:29



hi all,
maybe you're aware of numpypy - numpy port for pypy (pypy.org) - Python
language implementation with dynamic compilation.

Unfortunately, numpypy developmnent is very slow due to strict quality
standards and some other issues, so for my purposes I have provided some
missing numpypy funcs, in particular

* atleast_1d, atleast_2d, hstack, vstack, cumsum, isscalar, asscalar,
asfarray, flatnonzero, tile, zeros_like, ones_like, empty_like,
where, searchsorted

* with "axis" parameter: nan(arg)min, nan(arg)max, all, any

and have got some OpenOpt / FuncDesigner functionality working faster
than in CPython.

File with this functions you can get here

Also you may be interested in some info at http://openopt.org/PyPy
Regards, Dmitrey.
_______________________________________________
SciPy-User mailing list
SciPy-User< at >scipy.org
http://mail.scipy.org/mailman/listinfo/scipy-user

Re: subclassing ndarray : i want slice to return > ndarray, not subclass

M Daoust — 2012-05-24T10:40:25


I've sub-classes numpy.ndarray in some of my personal code, so I'm just 
hoping to understand why this is the wrong choice before I dig the 
hole any deeper.


So it's only wrong because it's hard to do right, and you can't do certain things? (which things?)

If you want a object to act mostly like a  numpy.ndarray, making a sub-class *should* be the right answer. 

Because isn't forwarding lookups to a wrapped class  just a re-implementation of the sub-classing mechanism?

Isn't it also tricky to get that "wrapping subclassing" right?

If you're going to sub-class something, it would be nice to use the built in sub-class machinery, for clarity... etc...


       _______________________________________________
SciPy-User mailing list
SciPy-User< at >scipy.org
http://mail.scipy.org/mailman/listinfo/scipy-user

efficiency of the simplex routine: R (optim) vsscipy.optimize.fmin

servant mathieu — 2012-05-24T08:15:51

Dear scipy users,

Again a question about optimization.

 I've just compared the efficiency of the simplex routine in R (optim) vs
scipy (fmin), when minimizing a chi-square. fmin is faster than optim,
but appears to be less efficient. In R, the value of the function is always
minimized step by step (there are of course some exceptions) while there is
lot of fluctuations in python. Given that the underlying simplex algorithm
is supposed to be the same, which mechanism is responsible for this
difference? Is it possible to constrain fmin so it could be more rigorous?

Cheers,
Mathieu
_______________________________________________
SciPy-User mailing list
SciPy-User< at >scipy.org
http://mail.scipy.org/mailman/listinfo/scipy-user

Re: Linear algebra problem

Warren Weckesser — 2012-05-24T04:29:19


Another way to say this is you want the nullspace of X.T.  See the SciPy
Cookbook entry http://www.scipy.org/Cookbook/RankNullspace for an example
of a function that computes the nullspace using the singular value
decomposition.

For example, in the following, X is 4 by 2:

In [57]: import rank_nullspace as rn

In [58]: X = array([[1,2],[3,4],[5,6],[7,8]])

In [59]: X
Out[59]:
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

In [60]: A = rn.nullspace(X.T).T

In [61]: A
Out[61]:
array([[-0.39450102,  0.24279655,  0.69790998, -0.5462055 ],
       [-0.37995913,  0.80065588, -0.46143436,  0.04073761]])


We get a 2 by 4 result; we can add trivial rows of zeros to make A 4 by 4:


In [62]: A = vstack((A, zeros((2,4))))

In [63]: A
Out[63]:
array([[-0.39450102,  0.24279655,  0.69790998, -0.5462055 ],
       [-0.37995913,  0.80065588, -0.46143436,  0.04073761],
       [ 0.        ,  0.        ,  0.        ,  0.        ],
       [ 0.        ,  0.        ,  0.        ,  0.        ]])


Verify that we h

Re: Linear algebra problem

Pauli Virtanen — 2012-05-23T20:12:59

23.05.2012 19:47, federico vaggi kirjoitti:
[clip]
[clip]

This problem is equivalent to looking for the subspace of zero
eigenvalue. You can do an eigenvalue or SVD decomposition of X, and then
grab the solution from the eigen-/singular vectors corresponding to zero
or small eigen/singular values.

Re: scipy.sparse.linalg.eigs is faster with k=8 than with k=1

Alejandro Weinstein — 2012-05-23T18:06:16

There is nothing random on my side. I just load the matrix and call
eigs (the timing is only for the function call). But I don't see a
significant variation each time I call the program. I would say is the
natural variation you observe in a multitasking environment. (I am
running Linux, in case that matters).

Alejandro.

Re: scipy.sparse.linalg.eigs is faster with k=8 than with k=1

Alejandro Weinstein — 2012-05-23T18:00:11

I see. Thanks for the answer.

Just for the record, if I set sigma=1, which means that eigs finds
eigenvalues near sigma using shift-invert mode, then the time
increases with k. These are the times (everything is the same as in
the original program, except that I use  code = 'eigs(P, k=%d,
sigma=1)' % k

Using sigma equal to 1.000000
k:  1, time:   3.1 ms
k:  2, time:   6.9 ms
k:  3, time:   5.4 ms
k:  4, time:   7.9 ms
k:  5, time:  16.8 ms
k:  6, time:  24.4 ms
k:  7, time:  17.1 ms
k:  8, time:  20.4 ms
k:  9, time:  21.2 ms
k: 10, time:  20.7 ms
k: 11, time:  23.5 ms
k: 12, time:  24.2 ms
k: 13, time:  32.0 ms
k: 14, time:  32.9 ms
k: 15, time:  23.3 ms
k: 16, time:  36.4 ms
k: 17, time:  49.4 ms
k: 18, time:  39.3 ms
k: 19, time:  42.2 ms

Alejandro.

Re: scipy.sparse.linalg.eigs is faster with k=8 thanwith k=1

Sergio Rojas — 2012-05-23T17:47:18

I do not have an answer to your question Alejandro, but I am curious about why the timing
 changes each time the code is executed. Is there any random allocation in the process of solving
 your problem?

 Sergio

 ---------------------------------------------------------------------- Message: 1 Date: Wed, 23 May 2012 09:33:15 -0600 From: Alejandro Weinstein <alejandro.weinstein< at >gmail.com> Subject: [SciPy-User] scipy.sparse.linalg.eigs is faster with k=8 than with k=1 To: scipy-user< at >scipy.org Message-ID: <CAPFc=oz+ck-_6msNQ7SadNb69RH9zwTgKSj1U0PfdsckH5vydA< at >mail.gmail.com> Content-Type: text/plain; charset=ISO-8859-1 Hi: I am using scipy.sparse.linalg.eigs with a 336x336 sparse matrix with 1144 nonzero entries. I only need the eigenvector corresponding to the larger eigenvalue, so I was running the function with k=1. However, I found that it is about 10 times faster to call the function with k=8. I am testing this with the following code (available here: https://gist.github.com/2775892): ######################

Linear algebra problem

federico vaggi — 2012-05-23T17:47:02

Hi,

I have a standard system, of type:

AX = B

Where:

X is a nxm matrix.

B is a mxn matrix.

A is a nxn matrix.

I have B and X, and I am trying to calculate A - however, B, is null matrix.

Using the default numpy solvers (
http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html#numpy.linalg.lstsq)
I obtain the trivial correct solution of A being a null matrix.

What's the most robust way to search for the solution which minimizes the
residuals, while still not returning a null matrix of A?  X, is usually
rank deficient, so I know I won't have an exact solution.

Thanks for all the help,

Federico
_______________________________________________
SciPy-User mailing list
SciPy-User< at >scipy.org
http://mail.scipy.org/mailman/listinfo/scipy-user

Re: scipy.sparse.linalg.eigs is faster with k=8 than withk=1

Pauli Virtanen — 2012-05-23T17:15:53

[clip]
[clip]

The sparse eigenvalue solver, ARPACK, is a Krylov method, and the size of the
Krylov subspace depends on `k` (you can also adjust it by specifying the `ncv`
parameter). I don't see any straightforward ways to predict how the exact
performance depends on the Krylov subspace size --- bigger is better, but on the
other hand, involves more work. The performance will in any case depend on the
structure of the matrix.

More on ARPACK:
ftp://ftp.caam.rice.edu/pub/people/sorensen/ARPACK/ug.ps.gz

scipy.sparse.linalg.eigs is faster with k=8 than withk=1

Alejandro Weinstein — 2012-05-23T15:33:15

Hi:

I am using scipy.sparse.linalg.eigs with a 336x336 sparse matrix with
1144 nonzero entries. I only need the eigenvector corresponding to the
larger eigenvalue, so I was running the function with k=1. However, I
found that it is about 10 times faster to call the function with k=8.

I am testing this with the following code (available here:
https://gist.github.com/2775892):

#############################################################
import timeit

setup = """
import numpy as np
import scipy.sparse
import scipy.io
from scipy.sparse.linalg import eigs

P = scipy.io.mmread('P.mtx')
"""

n = 10
for k in range(1,20):
    code = 'eigs(P, k=%d)' % k
    t = timeit.timeit(stmt=code, setup=setup, number=n) / n
    print 'k: %2d, time: %5.1f ms' % (k, 1000*t)

#############################################################

The output is

k:  1, time: 301.7 ms
k:  2, time: 242.6 ms
k:  3, time: 352.0 ms
k:  4, time: 168.8 ms
k:  5, time: 148.1 ms
k:  6, time:  93.2 ms
k:  7, time:  70.0 ms
k:  8, time:  29.3 ms
k:

Re: subclassing ndarray : i want slice to returnndarray, not subclass

pierre puiseux — 2012-05-21T13:57:05

First, my problem is : 
Imagine ArrayChild is a subclass of np.ndarray and 'ac' is an instance of ArrayChild.
I call very often ac[i] or ac[1:12], which calls methods ArrayChild.__getislice__() or ArrayChild.__getiitem__() 
But for each call Python/NumPy create a new instance of ArrayChild, and calls my (very expansive) ArrayChild.__array_finalize__

I'd like to avoid this creation, and I want a more direct access to ArrayChild's slice or item

Finally, i've found a solution (I'm not sure it's less expansive, anyway) : 

first, i create a ndarray view of my ArrayChild in __array_finalize__.
where i add this line : 
======================================
self.array_view = obj.view(np.ndarray)
======================================

Then i define methods ArrayChild.__getslice__ and ArrayChild.__getitem__ to call the getters of array_view instead of default getters :

======================================
    def __getslice__(self, *args, **kwargs):
        return np.ndarray.__getslice__(self.array_view, *args

Array Selection Help -Part2-

Lothar Ulferts — 2012-05-23T14:06:43

Dear list,

based upon the thread "Array Selection Help"
http://thread.gmane.org/gmane.comp.python.scientific.user/19412 I would like to
modifiy the task a little bit:
The arr1 contains numbers (label) , arr2 floating points (values). But, here it
is different, zones shouldn't be 'Multiparts'. A zone should be split into its
untouched parts. 
For example:
label:
100 100 100 -99 -99 -99       100 100 100 -99 -99 -99
100 100 -99 -99 200 200       100 100 -99 -99 200 200
-99 -99 -99 -99 200 200  =>   -99 -99 -99 -99 200 200 
300 300 300 300 300 300       300 300 300 300 300 300
200 200 200 -99 100 100       300 400 400 -99 500 500
200 200 200 -99 100 100       400 400 400 -99 500 500

values:
1.5 1.9 1.8 0.3 0.1 0.1
1.5 1.7 0.6 0.3 2.5 2.9
0.6 0.6 0.8 0.4 2.1 2.1
3.1 3.2 3.3 3.4 3.5 3.6
4.7 4.7 4.0 0.1 1.0 1.4
4.3 4.0 4.9 0.3 1.2 1.1

Result of zonal min should be:
1.7 1.7 1.7 -99 -99 -99
1.7 1.7 -99 0.3 2.9 2.9
-99 -99 -99 -99 2.9 2.9
3.6 3.6 3.6 3.6 3.6 3.6
4.0 4.0 4.0 -99 1.0 1.0
4.0 4.0 4.0 -99 1.0 1.0


Th

Re: Wrong Step Response

William — 2012-05-23T10:23:53



Ah thanks alot Fabrice, youre right!!

Got things mixed up!

Re: Wrong Step Response

Fabrice Silva — 2012-05-23T10:16:05

Are you sure you are not confusing the step response of a transfer
function with the step response of a looped system containing an
integrator ?

Once you close the loop, the global transfer function is not the one you
mentionned but
H = G/(1+G)
for a unity feedback (for example), which exhibits the oscillation and
the unity steady state.

What you did in your control engineering classes may be the closed-loop
system...

Re: Wrong Step Response

William — 2012-05-23T10:00:37




The integrator is used to reduce the overall error of the response so that it
reaches the constant steady state 1.
The low-pass is used to reduce the overshoot caused by the integrator.
If i didn't get it wrong in the control engineering class.
Probably have to check the notes again and run thru the MATLAB script again.

The response of TA1.jpg was made during a Lab (control engineering) at
University and the Prof checked it.

Re: Wrong Step Response

Fabrice Silva — 2012-05-23T08:36:58

Le mercredi 23 mai 2012 à 10:01 +0200, otti a écrit :

This transfer function involves an integrator (leading to the slope
after the transient) and a first-order low-pass filter (leading to a
damped contribution, the transient). 

IMHO, the step_response.png file is more probably correct than the
TA1.jpg file, as there is no second-order term that would possibly lead
to the oscillation shown in the latter. Moreover, the action of the
integrator for a step response can not lead to a constant steady state.
Am I wrong?

Looking at the fonts, I believe the step_response.png file comes from
matplotlib, and then from your python script. What makes you sure the
matlab script is correct?

Wrong Step Response

otti — 2012-05-23T08:01:31

Hello everyone,

after reading some threads about step response problems in the mailing list
i couldnt come up with a proper solution for my problem.

I've got the following transfer function:

G = Vr/(sT1*(1+sT2))

Vr = 2/15
T1 = 0.2
T2 = 1

For this i like to plot the step response so i made the following script:

*---Begin Script*

# some imports
import numpy as np
import matplotlib.pyplot as plt
import scipy as sp
from scipy import signal

# Constants
T1 = 0.2
T2 = 1
Vr = float(2)/15
Tsim = 50

# Denumerator
N0 = np.array([T1*T2 ,T1 , 0])

# numerator
Z0 = Vr

# create tfcn
sys = sp.signal.lti(Z0, N0)

# create the step response
t = np.linspace(0, Tsim, 1000)
u = np.arange(len(t))
u = np.ones_like(u)
yout = sp.signal.lsim2(sys, T=t, U=u)[1]

plt.figure(1)
plt.plot(t, u, t, yout/yout.max())
plt.grid("on")
plt.xlabel("t")
plt.ylabel("h(t)")
plt.title("Sprungantwort")
plt.show()

*---End Script*

This gives me the following response, which i know is not the rigth one 
because i made this one
already in a la