numpy-discussion — Discussion list for all users of Numerical Python

Re: [Numpy-discussion] Numpy fails to build with Python 2.5

[Andrew S. <str...@as...>]

William Grant wrote:

>Hi,
>
>I'm currently attempting to get scipy 0.5.1 into Ubuntu, however it
>currently cannot happen as numpy doesn't build with Python 2.5. I note
>that changeset 3109
>(http://projects.scipy.org/scipy/numpy/changeset/3109#file1) is meant to
>give 2.5 compatibility, but it is those bits which seem to break it. The
>end of the build log with the errors can be found at
>http://people.ubuntu.com.au/~fujitsu/numpy_error.txt.
>
>Has anybody got any ideas on how to fix this? A number of Ubuntu users
>want scipy 0.5.1, but that can't happen while it won't build with Python
>2.5.
>  
>
AFAIK a number of Ubuntu Dapper users are happily using my .debs with
Python 2.4 available at debs.astraw.com. This includes scipy 0.5.2.dev2197

Where are you getting that Ubuntu requires Python 2.5?

Re: [Numpy-discussion] sorting -inf, nan, inf

[Tim H. <tim...@ie...>]

A. M. Archibald wrote:
> On 19/09/06, Tim Hochberg <tim...@ie...> wrote:
>
>   
>> I'm not sure where the breakpoint is, but I was seeing failures for all
>> three sort types with N as high as 10000. I suspect that they're all
>> broken in the presence of  NaNs.  I further suspect you'd need some
>> punishingly slow n**2 algorithm to be robust in the presence of NaNs.
>>     
>
> Not at all. Just temporarily make NaNs compare greater than any other
> floating-point value and use quicksort (say). You can even do this for
> python lists without much trouble.
>   
I misspoke. What I meant here was keeping the behavior that people think 
that we already have but don't: NaNs stay in place and everything is 
sorted around them. And even that's not true, since you could just 
record where the NaNs are, remove them, sort and put them back. What I 
was really getting at was, that I'm guessing, and it's just a guess, 
that (a) none of the fast sorting algorithms do anything sensible unless 
special cased and (b) one could come up with a naive n**2 sort that does 
do something sensible without special casing (where sensible means leave 
the NaNs alone).
> That's actually a viable suggestion for numpy's sorting, although it
> would be kind of ugly to implement: do a quick any(isnan(A)), and if
> not, use the fast stock sorting algorithms; if there is a NaN
> somewhere in the array, use a version of the sort that has a tweaked
> comparison function so the NaNs wind up at the end and are easy to
> trim off.
>
> But the current situation, silently returning arrays in which the
> non-NaNs are unsorted, is really bad.
>   
If your going to do isnan anyway, why not just raise an exception. An 
array with NaNs in it can't be sorted by any common sense definition of 
sorting. Any treatment of NaNs is going to be arbitrary, so we might as 
well make the user specify what they want. "In the face of ambiguity, 
refuse the temptation to guess" and all that.

My favorite solution would be to make sort respect the invalid mode of 
seterr/geterr. However at the moment it doesn't seem to (in beta4 at 
least) but neither does add or multiply so those probably need to be 
looked at again....

-tim

Re: [Numpy-discussion] sorting -inf, nan, inf

[Tim H. <tim...@ie...>]

A. M. Archibald wrote:
> On 19/09/06, Charles R Harris <cha...@gm...> wrote:
>
>   
>> If this sort of thing can cause unexpected errors I wonder if it would be
>> worth it to have a global debugging flag that essentially causes  isnan to
>> be called before any function applications.
>>     
>
> That sounds very like the IEEE floating-point flags, which would be
> extremely useful to have, and which are being wored on, IIRC.
>   
Are you referring to numpy.geterr / seterr? These exist, but they don't 
seem to be working right as of 1.0b4 (my installation is a little out of 
date).

-tim

Re: [Numpy-discussion] sorting -inf, nan, inf

[A. M. A. <per...@gm...>]

On 19/09/06, Charles R Harris <cha...@gm...> wrote:

> If this sort of thing can cause unexpected errors I wonder if it would be
> worth it to have a global debugging flag that essentially causes  isnan to
> be called before any function applications.

That sounds very like the IEEE floating-point flags, which would be
extremely useful to have, and which are being wored on, IIRC.

A. M. Archibald

Re: [Numpy-discussion] sorting -inf, nan, inf

[Charles R H. <cha...@gm...>]

On 9/19/06, Tim Hochberg <tim...@ie...> wrote:
>
> Charles R Harris wrote:
> >
> >
> > On 9/19/06, *Tim Hochberg* <tim...@ie...
> > <mailto:tim...@ie...>> wrote:
> >
> >     A. M. Archibald wrote:
> >     > On 19/09/06, Tim Hochberg <tim...@ie...
> >     <mailto:tim...@ie...>> wrote:
> >     >
> >     >> Keith Goodman wrote:
> >     >>
> >     >>> In what order would you like argsort to sort the values -inf,
> >     nan, inf?
> >     >>>
> >     >>>
> >     >> Ideally, -inf should sort first, inf should sort last and nan
> >     should
> >     >> raise an exception if present.
> >     >>
> >     >> -tim
> >     >>
> >     >
> >     > Mmm. Somebody who's working with NaNs has more or less already
> >     decided
> >     > they don't want to be pestered with exceptions for invalid data.
> >     Do you really think so? In my experience NaNs are nearly always
> >     just an
> >     indication of a mistake somewhere that didn't get trapped for one
> >     reason
> >     or another.
> >
> >     >  I'd
> >     > be happy if they wound up at either end, but I'm not sure it's
> worth
> >     > hacking up the sort algorithm when a simple isnan() can pull
> >     them out.
> >     >
> >     Moving them to the end seems to be the worst choice to me. Leaving
> >     them
> >     alone is fine with me. Or raising an exception would be fine. Or
> doing
> >     one or the other depending on the error mode settings would be even
> >     better if it is practical.
> >
> >     > What's happening now is that NaN<a, NaN==a, and NaN>a are all
> >     false,
> >     > which rather confuses the sorting algorithm. But as long as it
> >     doesn't
> >     > actually *break* (that is, leave some of the non-NaNs incorrectly
> >     > sorted) I don't care.
> >     >
> >     Is that true? Are all of numpy's sorting algorithms robust against
> >     nontransitive objects laying around? The answer to that appears to
> be
> >     no. Try running this a couple of times to see what I mean:
> >
> >     n = 10
> >     for i in range(10):
> >         for kind in 'quicksort', 'heapsort', 'mergesort':
> >                  a = rand(n)
> >                  b = a.copy()
> >                  a[n//2] = nan
> >                  a.sort(kind=kind)
> >                  b.sort(kind=kind)
> >                  assert alltrue(a[:n//2] == b[:n//2]), (kind, a, b)
> >
> >
> >     The values don't correctly cross the inserted NaN and the sort is
> >     incorrect.
> >
> >
> > Except for heapsort those are doing insertion sorts because n is so
> > small. Heapsort is trickier to understand because of the way the heap
> > is formed and values pulled off.
> I'm not sure where the breakpoint is, but I was seeing failures for all
> three sort types with N as high as 10000. I suspect that they're all
> broken in the presence of  NaNs.  I further suspect you'd need some
> punishingly slow n**2 algorithm to be robust in the presence of NaNs.


Quicksort and Mergesort are divide and conquer types. When the pieces get
below a certain length they finish up with insertion sort as it is more
efficient for small bits. In numpy the breakover points are 15 and 20
respectively. I believe microsoft did a project on this and ended up with a
number somewhere around 7, but I didn't see that when doing the tuning for
numarray way back when. Not that I did a *lot* of careful tuning work ;)

> I'll look into that. I bet searchsorted gets messed up by nan's. Do
> > you think it worthwhile to worry about it?
>
> No. But that's because it's my contention is that any sequence with NaNs
> in it is *not sorted* and thus isn't suitable input for searchsorted.


If this sort of thing can cause unexpected errors I wonder if it would be
worth it to have a global debugging flag that essentially causes  isnan to
be called before any function applications.

Chuck

Re: [Numpy-discussion] Resolution of tickets.

[Robert K. <rob...@gm...>]

Matthew Brett wrote:
> Hi,
> 
>>> You have to be logged in to the Trac site.  If you have SVN write access
>>> you should be able to log in.  Then there is a "resolution" section at
>>> the very bottom.
>> Ah,  that works. I orignally tried to register and discovered that charris
>> was already taken and I didn't know what password to use. I've now deleted
>> the charris208 account.
> 
> Not for me, when logged on with my SVN username.   I took Robert's
> email to mean we needed specific permission (over and above SVN write
> access) to resolve tickets - is that not the case?

It used to be the case that the subversion password database was used as the 
Trac's password database. This is no longer the case since we need to require 
registration by non-developers.

*Operationally*, people added to the subversion write list should also be be 
provided with appropriate Trac privileges, but this did not happen in your case. 
I will fix that.

-- 
Robert Kern

"I have come to believe that the whole world is an enigma, a harmless enigma
  that is made terrible by our own mad attempt to interpret it as though it had
  an underlying truth."
   -- Umberto Eco

Re: [Numpy-discussion] sorting -inf, nan, inf

[A. M. A. <per...@gm...>]

On 19/09/06, Tim Hochberg <tim...@ie...> wrote:

> I'm not sure where the breakpoint is, but I was seeing failures for all
> three sort types with N as high as 10000. I suspect that they're all
> broken in the presence of  NaNs.  I further suspect you'd need some
> punishingly slow n**2 algorithm to be robust in the presence of NaNs.

Not at all. Just temporarily make NaNs compare greater than any other
floating-point value and use quicksort (say). You can even do this for
python lists without much trouble.

That's actually a viable suggestion for numpy's sorting, although it
would be kind of ugly to implement: do a quick any(isnan(A)), and if
not, use the fast stock sorting algorithms; if there is a NaN
somewhere in the array, use a version of the sort that has a tweaked
comparison function so the NaNs wind up at the end and are easy to
trim off.

But the current situation, silently returning arrays in which the
non-NaNs are unsorted, is really bad.

A. M. Archibald

Re: [Numpy-discussion] sorting -inf, nan, inf

[A. M. A. <per...@gm...>]

On 19/09/06, Tim Hochberg <tim...@ie...> wrote:
> A. M. Archibald wrote:
> > Mmm. Somebody who's working with NaNs has more or less already decided
> > they don't want to be pestered with exceptions for invalid data.
> Do you really think so? In my experience NaNs are nearly always just an
> indication of a mistake somewhere that didn't get trapped for one reason
> or another.

Well, I said that because for an image porcessing project I was doing,
the easiest thing to do with certain troublesome pixels was to fill in
NaNs, and then at the end replace the NaNs with sensible values. It
seems as if the point of NaNs is to allow you to keep working with
those numbers that make sense while ingoring those that don't. If you
wanted exceptions, why not get them as soon as the first NaN would
have been generated?

> >  I'd
> > be happy if they wound up at either end, but I'm not sure it's worth
> > hacking up the sort algorithm when a simple isnan() can pull them out.
> >
> Moving them to the end seems to be the worst choice to me. Leaving them
> alone is fine with me. Or raising an exception would be fine. Or doing
> one or the other depending on the error mode settings would be even
> better if it is practical.

I was just thinking in terms of easy removal.

> Is that true? Are all of numpy's sorting algorithms robust against
> nontransitive objects laying around? The answer to that appears to be
> no. Try running this a couple of times to see what I mean:

> The values don't correctly cross the inserted NaN and the sort is incorrect.

You're quite right: when NaNs are present in the array, sorting and
then removing them does not yield a sorted array. For example,
mergesort just output
[ 2.          4.          6.          9.                 nan  0.          1.
  3.          5.          7.          8.        ]

The other two are no better (and arguably worse).  Python's built-in
sort() for lists has the same problem.

This is definitely a bug, and the best way to fix it is not clear to
me - perhaps sort() needs to always do any(isnan(A)) before starting
to sort. I don't really like raising an exception, but sort() isn't
really very meaningful with NaNs in the array. The only other option I
can think of is to somehow remove them, sort without, and reintroduce
them at the end, which is going to be a nightmare when sorting a
single axis of a large array. Or, I suppose, sort() could simply fill
the array with NaNs; I'm sure users will love that.

A. M. Archibald

Re: [Numpy-discussion] sorting -inf, nan, inf

[Tim H. <tim...@ie...>]

Charles R Harris wrote:
>
>
> On 9/19/06, *Tim Hochberg* <tim...@ie... 
> <mailto:tim...@ie...>> wrote:
>
>     A. M. Archibald wrote:
>     > On 19/09/06, Tim Hochberg <tim...@ie...
>     <mailto:tim...@ie...>> wrote:
>     >
>     >> Keith Goodman wrote:
>     >>
>     >>> In what order would you like argsort to sort the values -inf,
>     nan, inf?
>     >>>
>     >>>
>     >> Ideally, -inf should sort first, inf should sort last and nan
>     should
>     >> raise an exception if present.
>     >>
>     >> -tim
>     >>
>     >
>     > Mmm. Somebody who's working with NaNs has more or less already
>     decided
>     > they don't want to be pestered with exceptions for invalid data.
>     Do you really think so? In my experience NaNs are nearly always
>     just an
>     indication of a mistake somewhere that didn't get trapped for one
>     reason
>     or another.
>
>     >  I'd
>     > be happy if they wound up at either end, but I'm not sure it's worth
>     > hacking up the sort algorithm when a simple isnan() can pull
>     them out.
>     >
>     Moving them to the end seems to be the worst choice to me. Leaving
>     them
>     alone is fine with me. Or raising an exception would be fine. Or doing
>     one or the other depending on the error mode settings would be even
>     better if it is practical.
>
>     > What's happening now is that NaN<a, NaN==a, and NaN>a are all
>     false,
>     > which rather confuses the sorting algorithm. But as long as it
>     doesn't
>     > actually *break* (that is, leave some of the non-NaNs incorrectly
>     > sorted) I don't care.
>     >
>     Is that true? Are all of numpy's sorting algorithms robust against
>     nontransitive objects laying around? The answer to that appears to be
>     no. Try running this a couple of times to see what I mean:
>
>     n = 10
>     for i in range(10):
>         for kind in 'quicksort', 'heapsort', 'mergesort':
>                  a = rand(n)
>                  b = a.copy()
>                  a[n//2] = nan
>                  a.sort(kind=kind)
>                  b.sort(kind=kind)
>                  assert alltrue(a[:n//2] == b[:n//2]), (kind, a, b)
>
>
>     The values don't correctly cross the inserted NaN and the sort is
>     incorrect.
>
>
> Except for heapsort those are doing insertion sorts because n is so 
> small. Heapsort is trickier to understand because of the way the heap 
> is formed and values pulled off.
I'm not sure where the breakpoint is, but I was seeing failures for all 
three sort types with N as high as 10000. I suspect that they're all 
broken in the presence of  NaNs.  I further suspect you'd need some 
punishingly slow n**2 algorithm to be robust in the presence of NaNs.

> I'll look into that. I bet searchsorted gets messed up by nan's. Do 
> you think it worthwhile to worry about it?

No. But that's because it's my contention is that any sequence with NaNs 
in it is *not sorted* and thus isn't suitable input for searchsorted.

-tim

Re: [Numpy-discussion] sorting -inf, nan, inf

[Charles R H. <cha...@gm...>]

On 9/19/06, Tim Hochberg <tim...@ie...> wrote:
>
> A. M. Archibald wrote:
> > On 19/09/06, Tim Hochberg <tim...@ie...> wrote:
> >
> >> Keith Goodman wrote:
> >>
> >>> In what order would you like argsort to sort the values -inf, nan,
> inf?
> >>>
> >>>
> >> Ideally, -inf should sort first, inf should sort last and nan should
> >> raise an exception if present.
> >>
> >> -tim
> >>
> >
> > Mmm. Somebody who's working with NaNs has more or less already decided
> > they don't want to be pestered with exceptions for invalid data.
> Do you really think so? In my experience NaNs are nearly always just an
> indication of a mistake somewhere that didn't get trapped for one reason
> or another.
>
> >  I'd
> > be happy if they wound up at either end, but I'm not sure it's worth
> > hacking up the sort algorithm when a simple isnan() can pull them out.
> >
> Moving them to the end seems to be the worst choice to me. Leaving them
> alone is fine with me. Or raising an exception would be fine. Or doing
> one or the other depending on the error mode settings would be even
> better if it is practical.
>
> > What's happening now is that NaN<a, NaN==a, and NaN>a are all false,
> > which rather confuses the sorting algorithm. But as long as it doesn't
> > actually *break* (that is, leave some of the non-NaNs incorrectly
> > sorted) I don't care.
> >
> Is that true? Are all of numpy's sorting algorithms robust against
> nontransitive objects laying around? The answer to that appears to be
> no. Try running this a couple of times to see what I mean:
>
> n = 10
> for i in range(10):
>     for kind in 'quicksort', 'heapsort', 'mergesort':
>              a = rand(n)
>              b = a.copy()
>              a[n//2] = nan
>              a.sort(kind=kind)
>              b.sort(kind=kind)
>              assert alltrue(a[:n//2] == b[:n//2]), (kind, a, b)
>
>
> The values don't correctly cross the inserted NaN and the sort is
> incorrect.


Except for heapsort those are doing insertion sorts because n is so small.
Heapsort is trickier to understand because of the way the heap is formed and
values pulled off. I'll look into that. I bet searchsorted gets messed up by
nan's. Do you think it worthwhile to worry about it?

Chuck

Re: [Numpy-discussion] sorting -inf, nan, inf

[Tim H. <tim...@ie...>]

A. M. Archibald wrote:
> On 19/09/06, Tim Hochberg <tim...@ie...> wrote:
>   
>> Keith Goodman wrote:
>>     
>>> In what order would you like argsort to sort the values -inf, nan, inf?
>>>
>>>       
>> Ideally, -inf should sort first, inf should sort last and nan should
>> raise an exception if present.
>>
>> -tim
>>     
>
> Mmm. Somebody who's working with NaNs has more or less already decided
> they don't want to be pestered with exceptions for invalid data.
Do you really think so? In my experience NaNs are nearly always just an 
indication of a mistake somewhere that didn't get trapped for one reason 
or another.

>  I'd
> be happy if they wound up at either end, but I'm not sure it's worth
> hacking up the sort algorithm when a simple isnan() can pull them out.
>   
Moving them to the end seems to be the worst choice to me. Leaving them 
alone is fine with me. Or raising an exception would be fine. Or doing 
one or the other depending on the error mode settings would be even 
better if it is practical.

> What's happening now is that NaN<a, NaN==a, and NaN>a are all false,
> which rather confuses the sorting algorithm. But as long as it doesn't
> actually *break* (that is, leave some of the non-NaNs incorrectly
> sorted) I don't care.
>   
Is that true? Are all of numpy's sorting algorithms robust against 
nontransitive objects laying around? The answer to that appears to be 
no. Try running this a couple of times to see what I mean:

n = 10
for i in range(10):
    for kind in 'quicksort', 'heapsort', 'mergesort':
             a = rand(n)
             b = a.copy()
             a[n//2] = nan
             a.sort(kind=kind)
             b.sort(kind=kind)
             assert alltrue(a[:n//2] == b[:n//2]), (kind, a, b)


The values don't correctly cross the inserted NaN and the sort is incorrect.

-tim

Re: [Numpy-discussion] sorting -inf, nan, inf

[Sasha <nd...@ma...>]

On 9/19/06, Keith Goodman <kwg...@gm...> wrote:
> Is there an easy way to use isnan to pull out the nans if the matrix I
> am sorting has more than one column?
>
There seems to be a "nan_to_num" function that converts nans to zeros,
but I would suggest just using fancy indexing to fill the nans with
appropriate values:

x[isnan(x)] = inf # if you want nans on the right

Re: [Numpy-discussion] sorting -inf, nan, inf

[Keith G. <kwg...@gm...>]

On 9/19/06, A. M. Archibald <per...@gm...> wrote:
> On 19/09/06, Tim Hochberg <tim...@ie...> wrote:
> > Keith Goodman wrote:
> > > In what order would you like argsort to sort the values -inf, nan, inf?
> > >
> > Ideally, -inf should sort first, inf should sort last and nan should
> > raise an exception if present.
> >
> > -tim
>
> Mmm. Somebody who's working with NaNs has more or less already decided
> they don't want to be pestered with exceptions for invalid data. I'd
> be happy if they wound up at either end, but I'm not sure it's worth
> hacking up the sort algorithm when a simple isnan() can pull them out.

Is there an easy way to use isnan to pull out the nans if the matrix I
am sorting has more than one column?

Re: [Numpy-discussion] sorting -inf, nan, inf

[A. M. A. <per...@gm...>]

On 19/09/06, Tim Hochberg <tim...@ie...> wrote:
> Keith Goodman wrote:
> > In what order would you like argsort to sort the values -inf, nan, inf?
> >
> Ideally, -inf should sort first, inf should sort last and nan should
> raise an exception if present.
>
> -tim

Mmm. Somebody who's working with NaNs has more or less already decided
they don't want to be pestered with exceptions for invalid data. I'd
be happy if they wound up at either end, but I'm not sure it's worth
hacking up the sort algorithm when a simple isnan() can pull them out.

What's happening now is that NaN<a, NaN==a, and NaN>a are all false,
which rather confuses the sorting algorithm. But as long as it doesn't
actually *break* (that is, leave some of the non-NaNs incorrectly
sorted) I don't care.

A. M. Archibald

Re: [Numpy-discussion] max argmax combo

[Charles R H. <cha...@gm...>]

On 9/19/06, Bill Baxter <wb...@gm...> wrote:
>
> On 9/20/06, Francesc Altet <fa...@ca...> wrote:
> > A Dimarts 19 Setembre 2006 19:21, Charles R Harris va escriure:
> > >
> > > Do you want both the indexes and index sorted array returned, or just
> sort
> > > the array using indexes, i.e., something like
> > >
> > > a.sort(kind="quicksort", method="indirect")
> >
> > Uh, I don't understand what do you mean by "sort the array using
> indexes",
> > sorry.
> >
>
> I think he meant do an argsort first, then use fancy indexing to get
> the sorted array.
> For a 1-d array that's just
>
>   ind = A.argsort()
>   Asorted = A[ind]
>
> That should be O(N lg N + N), aka O(N lg N)
> For A >1-d, you need an indexing expression that's a little more
> complicated, hence the discussion about making an "extract" function
> for that purpose.  Then you could say:
>
>   ind = A.argsort(axis=d)
>   Asorted = A.extract(ind,axis=d)


I'm also thinking of the name argtake.

Chuck

Re: [Numpy-discussion] sorting -inf, nan, inf

[Sasha <nd...@ma...>]

On 9/19/06, Tim Hochberg <tim...@ie...> wrote:
> Ideally, -inf should sort first, inf should sort last and nan should
> raise an exception if present.

I disagree. NumPy sort leaving nan's where they are is probably just a
side-effect of nans unusual properties (both nan<x and nan>x is always
false), but it is a logical choice.  Checking for nan will inevitably
slow the most common use case.  If you want an exception, just check
isnan(x).any() before sort.

Re: [Numpy-discussion] sorting -inf, nan, inf

[Charles R H. <cha...@gm...>]

On 9/19/06, Tim Hochberg <tim...@ie...> wrote:
>
> Keith Goodman wrote:
> > In what order would you like argsort to sort the values -inf, nan, inf?
> >
> Ideally, -inf should sort first, inf should sort last and nan should
> raise an exception if present.
>
> -tim


That sounds right. Nan can't be compared because, well, it is undefined. For
instance:

In [73]: a = arange(2)

In [74]: a/0
Out[74]: array([0, 0])

In [75]: a/0.0
Out[75]: array([              nan,               inf])

In [76]: a/(-0.0)
Out[76]: array([              nan,              -inf])

I.e., 0.0/0.0 is undefined. But unless the hardware generates the exception
I would be loath to introduce checks in the code. Putting a check in the
innermost loop of the sorts would cost significant time.

But look at the integer division by zero where the IEEE stuff has no
relevence. That sure looks like a bug to me.
<snip>

Chuck

Re: [Numpy-discussion] max argmax combo

[Bill B. <wb...@gm...>]

On 9/20/06, Francesc Altet <fa...@ca...> wrote:
> A Dimarts 19 Setembre 2006 19:21, Charles R Harris va escriure:
> >
> > Do you want both the indexes and index sorted array returned, or just sort
> > the array using indexes, i.e., something like
> >
> > a.sort(kind="quicksort", method="indirect")
>
> Uh, I don't understand what do you mean by "sort the array using indexes",
> sorry.
>

I think he meant do an argsort first, then use fancy indexing to get
the sorted array.
For a 1-d array that's just

  ind = A.argsort()
  Asorted = A[ind]

That should be O(N lg N + N), aka O(N lg N)
For A >1-d, you need an indexing expression that's a little more
complicated, hence the discussion about making an "extract" function
for that purpose.  Then you could say:

  ind = A.argsort(axis=d)
  Asorted = A.extract(ind,axis=d)

and it should just work no matter what 'd' is.

--bb

Re: [Numpy-discussion] sorting -inf, nan, inf

[Tim H. <tim...@ie...>]

Keith Goodman wrote:
> In what order would you like argsort to sort the values -inf, nan, inf?
>   
Ideally, -inf should sort first, inf should sort last and nan should 
raise an exception if present.

-tim


> In numpy 1.0b1 nan is always left where it began:
>
> EXAMPLE 1
>
>   
>>> x
>>>       
>
> matrix([[              inf],
>         [             -inf],
>         [              nan]])
>   
>>> x[x.argsort(0),:]
>>>       
>
> matrix([[             -inf],
>         [              inf],
>         [              nan]])
>
> EXAMPLE 2
>
>   
>>> x
>>>       
>
> matrix([[                  nan],
>         [                  inf],
>         [                 -inf]])
>   
>>> x[x.argsort(0),:]
>>>       
>
> matrix([[                  nan],
>         [                 -inf],
>         [                  inf]])
>
>
> I would like nan to be in the middle between -inf and inf.
>
> -------------------------------------------------------------------------
> Take Surveys. Earn Cash. Influence the Future of IT
> Join SourceForge.net's Techsay panel and you'll get the chance to share your
> opinions on IT & business topics through brief surveys -- and earn cash
> http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
> _______________________________________________
> Numpy-discussion mailing list
> Num...@li...
> https://lists.sourceforge.net/lists/listinfo/numpy-discussion
>
>
>   

[Numpy-discussion] sorting -inf, nan, inf

[Keith G. <kwg...@gm...>]

In what order would you like argsort to sort the values -inf, nan, inf?

In numpy 1.0b1 nan is always left where it began:

EXAMPLE 1

>> x

matrix([[              inf],
        [             -inf],
        [              nan]])
>> x[x.argsort(0),:]

matrix([[             -inf],
        [              inf],
        [              nan]])

EXAMPLE 2

>> x

matrix([[                  nan],
        [                  inf],
        [                 -inf]])
>> x[x.argsort(0),:]

matrix([[                  nan],
        [                 -inf],
        [                  inf]])


I would like nan to be in the middle between -inf and inf.

Re: [Numpy-discussion] Resolution of tickets.

[Matthew B. <mat...@gm...>]

Hi,

> > You have to be logged in to the Trac site.  If you have SVN write access
> > you should be able to log in.  Then there is a "resolution" section at
> > the very bottom.
>
> Ah,  that works. I orignally tried to register and discovered that charris
> was already taken and I didn't know what password to use. I've now deleted
> the charris208 account.

Not for me, when logged on with my SVN username.   I took Robert's
email to mean we needed specific permission (over and above SVN write
access) to resolve tickets - is that not the case?

Best,

Matthew

Re: [Numpy-discussion] Resolution of tickets.

[Charles R H. <cha...@gm...>]

On 9/19/06, Travis Oliphant <oli...@ie...> wrote:
>
> Charles R Harris wrote:
> > Question,
> >
> > How does one mark a ticket as fixed? I don't see this field in the
> > ticket views I get, is there a list of accepted fixers?
> >
> You have to be logged in to the Trac site.  If you have SVN write access
> you should be able to log in.  Then there is a "resolution" section at
> the very bottom.


Ah,  that works. I orignally tried to register and discovered that charris
was already taken and I didn't know what password to use. I've now deleted
the charris208 account.

Chuck

[Numpy-discussion] =?GB2312?B?t8eyxs7xvq3A7bXEssbO8bncwO0tybPFzMSjxOK/zrPM?=

[<hj...@to...>]

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<style type="text/css">
<!--
.td {
	font-size: 12px;
	color: #313131;
	line-height: 20px;
	font-family: "Arial", "Helvetica", "sans-serif";
}
-->
</style>
</head>

<body leftmargin="0" background="http://bo.sohu.com//images/img20040502/dj_bg.gif">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
  <tr>
    <td height="31" background="http://igame.sina.com.cn/club/images/topmenu/topMenu_8.gif" class="td"><div align="center"><font color="#FFFFFF">主办单位：易腾企业管理咨询有限公司</font></div></td>
  </tr>
</table>
<br>
<table width="673" border="0" align="center" cellpadding="0" cellspacing="0">
  <tr>
    <td height="62" bgcolor="#8C8C8C"> 
      <div align="center"> 
        <table width="100%" border="0" cellspacing="1" cellpadding="0">
          <tr>
            <td height="62" bgcolor="#F3F3F3">
			<p align="center"><span style="background-color: #F3F3F3">
			<font size="5"><span style="font-weight: 700">&nbsp;非</span></font></span><font size="5"><span style="font-weight: 700; background-color: #F3F3F3">财务经理的财务管理<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -</span></font><font size="4"><span style="background-color: #F3F3F3">沙盘模拟课程</span></font></td>      
          </tr>
        </table>
        <font color="#FF0000" size="+3" face="黑体"></font></div></td>
  </tr>
</table>

<table width="673" border="0" align="center" cellpadding="0" cellspacing="0" class="td" height="1488">
  <tr> 
    <td bgcolor="#8C8C8C" height="22">　</td>
  </tr>
  <tr>
    <td height="1466" bgcolor="#FFFFFF"> <div align="center"> 
        <table width="99%" border="0" cellspacing="0" cellpadding="0">
          <tr> 
            <td width="17%" height="20" bgcolor="#BF0000" class="td"> 
              <div align="center"><font color="#FFFFFF">[课 程 背 景]</font></div></td>                         
            <td width="83%" class="td">　</td>
          </tr>
          <tr> 
            <td height="74" colspan="2" class="td"><font FACE="??ì?,SimSun" LANG="ZH-CN">
              <p ALIGN="JUSTIFY">&nbsp;&nbsp;</font><font lang="ZH-CN" size="2">&nbsp;</font><font lang="ZH-CN" size="2">每一位管理和技术人员都清楚地懂得，单纯从技术角度衡量为合算的方案，也许却是一个财务陷阱，表面赢利而暗地里亏损，使经营者无法接受。如何将技术手段与财务运作相结合，使每位管理和技术人员都从老板的角度进行思考 , 有效地规避财务陷阱，实现管理决策与经营目标的一致性？本课程通过沙盘模拟实施体验式教学，每个小组 5-6 人模拟公司的生产、销售和财务分析过程，学员在模拟对抗中相互激发、体验决策与经营企业的乐趣，同时讲师与学员共同分享解决问题的模型与工具，使学员 " 身同体受 " ，完成从 know-what 向 know-why 转化。本课程通过二十<span style="letter-spacing: -1pt">八个实际案例分析，使企业各级管理和技术人员掌握财务管理知识，利用财务信息改进管理决策，实现管理效益最大化</span>。<br>              
              ★ 对会计与财务管理有基本了解, 提高日常管理活动的财务可行性;<br>              
              ★ 掌握合乎财务原则的管理决策方法 , 与老板的思维同步；<br>              
              ★ 通过成本分析，找到有效降低成本的途径；<br>              
              ★ 通过边际效应分析，实施正确的成本决策；<br>              
              ★ 掌握业绩评价的依据和方法，评估经营业绩 , 实施科学的业绩考核。</font></td>                  
          </tr>
        </table>
      </div>
      <div align="center" style="width: 671; height: 1"> </div>
      <div align="center"> 
        <table width="99%" height="84" border="0" cellpadding="0" cellspacing="0">
          <tr> 
            <td width="17%" height="20" bgcolor="#0080C0" class="td"> <div align="center"><font color="#FFFFFF">[课                        
                程 大 纲]</font></div></td>                       
            <td width="83%" class="td">　</td>
          </tr>
          <tr> 
            <td height="64" colspan="2" class="td"> <p><font lang="ZH-CN" size="2"><font color="#FF0000">一、企业财务管理的内容及管理会计的作用</font><br>
              1、财务会计的职能<br>
              2、财务专家的思维模式<br>
              3、财务工作的基本内容<br>
              4、财务管理的四个基本原理<br>
              5、会计工作的十三个基本原则<br>
              <font color="#FF0000">二、如何阅读和分析财务报表</font><br>
              1、会计报表的构成<br>
              2、资产负债表：<br>
  资产负债表的逻辑结构与主要内容（透视资产负债表的各个部分）<br>
  解读资产负债表（应收款、存货、应付款、固定资产、借款、股东权益）<br>
  企业拥有何物，谁拥有企业<br>
  财务杠杆的运用 ---- 资本结构分析<br>              
              3、损益表：<br>
  损益表的逻辑结构与主要内容<br>
  如何正确确认收入避免 ” 苹果电脑事件 ”<br>              
  如何计算制造成本 , 反映每种产品的实际贡献<br>              
  如何计算共同成本<br>
  如何计算息税前利润和净利润<br>
              4、现金流量表的阅读与分析<br>
  现金流量表的逻辑结构与主要内容<br>
              5、会计报表之间的关系（ Dupont 模型的应用）<br>              
              6、如何从会计报表读懂企业经营状况<br>
              &nbsp;&#8226;  案例分析：读报表，判断企业业绩水平<br>              
              <font color="#FF0000">三、如何利用财务数据分析并改善经营绩效</font><br>
              1、财务比率分析<br>
              2、关键财务指标解析<br>
  总资产收益率 / 净资产收益率<br>              
  营业利润率 / 总资产周转率<br>              
  总资产周转率与资产管理<br>
              3、盈利能力分析：资产回报率、股东权益回报率、资产流动速率<br>         
              4、风险指数分析：流动比率、负债 / 权益比率、营运偿债能力<br>              
              5、财务报表综合解读：综合运用财务信息透视公司运作水平<br>
              ◆ 案例分析：某上市公司的财务状况分析与经营绩效评价<br>              
              <font color="#FF0000">四、成本分析与成本决策</font><br>
              1、产品成本的概念和构成<br>
  成本习性分析<br>
  完全成本法<br>
  变动成本法<br>
              2、ＣＶＰ（本－量－利）分析与运用<br>
              3、固定成本与边际效应分析<br>
              4、如何运用目标成本法控制产品成本，保证利润水平<br>
              5、如何运用 ABC 作业成本法进行管理分析，实施精细成本管理<br>              
              6、如何针对沉没成本和机会成本进行正确决策<br>
              7、如何改善采购、生产等环节的运作以改良企业的整体财务状况<br>
              ◆ 综合案例分析<br>              
              <font color="#FF0000">五、投资决策</font><br>
              1、管理和技术方案的可行性分析<br>
              2、设备改造与更新的决策分析<br>
              3、如何根据成本与市场进行合理定价<br>
              4、长期投资项目的现金流分析<br>
              5、资金的时间价值<br>
              6、投资项目评价方法<br>
   回收期法<br>
   净现值法<br>
   内部收益率法<br>
              ◆ 综合案例演练<br>              
              <font color="#FF0000">六、绩效考评与内部控制</font><br>
              1、如何确定责任成本？<br>
              2、如何实施内部控制<br>
              3、如何针对成本中心进行费用控制<br>
              4、如何针对利润中心进行业绩考核<br>
              5、如何针对投资中心进行业绩评价<br>
              6、如何运用内部市场链进行管理，使每个部门都成为利润中心<br>
              &#8226;  案例研讨： GE 和海尔的绩效考评</font>                  
              </p></td>
          </tr>
        </table>
        <table width="99%" height="84" border="0" cellpadding="0" cellspacing="0">
          <tr> 
            <td width="17%" height="20" bgcolor="#0080C0" class="td"> 
              <div align="center"><font color="#FFFFFF">[导 师 简 介]</font></div></td>                      
            <td width="83%" class="td">　</td>
          </tr>
          <tr> 
            <td height="64" colspan="2" class="td"> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#FF0000">&nbsp;</font>&nbsp;&nbsp;Mr Wang ，管理工程硕士、高级经济师，国际职业培训师协会认证职业培训师，历任跨国公司生产负责人、工业工程经理、管理会计分析师、营运总监等高级管理职务多年，同时还担任 &lt; 价值工程 > 杂志审稿人、辽宁省营口市商业银行独立董事等职务，对企业管理有较深入的研究。 王老师主要从事 IE 技术应用、成本控制、管理会计决策等课程的讲授，先后为 IBM 、 TDK 、松下、可口可乐、康师傅、汇源果汁、雪津啤酒、吉百利食品、冠捷电子、 INTEX 明达塑胶、正新橡胶、美国 ITT 集团、广上科技、美的空调、中兴通讯、京信通信、联想电脑，应用材料 ( 中国 ) 公司、艾克森 - 金山石化、中国化工进出口公司、正大集团大福饲料、厦华集团、灿坤股份、 NEC 东金电子、太原钢铁集团、 PHILIPS 、深圳开发科技、大冷王运输制冷、三洋华强、 TCL 、美的汽车、上海贝尔阿尔卡特、天津扎努西、上海卡博特等知名企业提供项目辅导或专题培训。王老师授课经验丰富，风格幽默诙谐、逻辑清晰、过程互动，案例生动、深受学员喜爱。                
              </p></td>
          </tr>
        </table>
      </div>
      <div align="center"> 
        <table width="99%" border="0" cellpadding="0" cellspacing="0" height="80">
          <tr> 
            <td width="17%" height="25" bgcolor="#0080C0" class="td"> <div align="center"><font color="#FFFFFF">[时间/地点/报名]</font></div></td>
            <td width="83%" class="td" height="25">　</td>
          </tr>
          <tr> 
            <td height="55" colspan="2" class="td"> 
              <p style="line-height: 200%; margin-top: 2; margin-bottom: 2"><font size="2"> 
              <b>
              &nbsp;公开课报名/咨询:&nbsp;</b>&nbsp;&nbsp;&nbsp; 谢小姐&nbsp;&nbsp; 
              021-5118 7126&nbsp;<br>
              </font><font size="2"><b>&nbsp;时间:&nbsp;</b> 
              9月28-29日&nbsp;                  
              (周四、五)&nbsp; &nbsp;&nbsp; <b>地点: </b> 上海&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;    
              <b>费用: </b> 
              1980元/人(含教材,午餐等)&nbsp;&nbsp; &nbsp;&nbsp;四人以上参加,赠予一名名额</font></p>   
              </td>
          </tr>
        </table>
      </div>
      <table width="99%" height="35" border="0" align="center" cellpadding="0" cellspacing="0">
        <tr> 
          <td height="15" class="td"> <p><font color="#000000" size="2">&nbsp;&nbsp;<b>厂内培训和咨询项目:</b></font><font color="#000000" size="1"><br>
            &nbsp;&nbsp;&nbsp;</font><font size="2">&nbsp;&nbsp;&nbsp;<span style="letter-spacing: -1pt">&nbsp;易腾公司致力于生产、质量、成本节约等各方面的课程培训与项目咨询, 
            欢迎您根据需要提出具体要求，我们将为您</span><span style="letter-spacing: -3pt">制&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 
            厂内</span><span style="letter-spacing: -1pt">培训或咨询项目。<br>
            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 内训联系： 021-5118 
            7132&nbsp;&nbsp;&nbsp; 刘小姐</span>&nbsp;</font> 
            </p>
            </td>
        </tr>
      </table>
      <table width="99%" height="35" border="0" align="center" cellpadding="0" cellspacing="0">
        <tr> 
          <td height="15" class="td"> <font size="2"><b> 注:尊敬的客户：</b><br>
            　&nbsp;    
			您好！以下内容为商-务-广-告;如果对您的工作及生活带来不便，在此深表歉意;如您不需要,请与技术部联系</font><font size="2" color="#000000"><br>
            &nbsp;&nbsp;&nbsp;&nbsp; 联系电话:&nbsp; 021-5118 7131&nbsp;&nbsp;&nbsp; 张小姐 </font></td>   
        </tr>
      </table> </td>
  </tr>
</table>
<p align="center">　</p>
</body>
</html>

Re: [Numpy-discussion] 1.0b5 Installation on OS X

[Russell E. O. <ro...@ce...>]

In article <450...@no...>,
 Christopher Barker <Chr...@no...> wrote:

> David Andrews wrote:
> 
> > I'm unable to install the 1.0b5 release from the .mpkg on OS X - when
> > it comes to the two checkboxes to select the platlib and the scripts,
> > both are greyed out.  The installer then claims 'Cannot continue:
> > Nothing to install'.
> 
> hmmm. It works just fine for me -- just clicking OK as I go merrily along.
> 
> OS version? python version? processor?
> 
> Also, try deleting or renaming any existing install you have from 
> site-packages, then try again.

In addition to that, I suggest also deleting any relevant receipts in 
/Library/Receipts
It is a long shot, but receipt files have occasionally prevented me from 
installing software, though I confess only when an older version of 
something.

-- Russell

Re: [Numpy-discussion] arr.dtype.kind is 'i' for dtype=unit !?

[Scott R. <sr...@nr...>]

> > Can anybody on a 64-bit system confirm?
>
> I'm on 64-bit Debian:
>
> In [11]: arr=N.arange(10,dtype=N.uint)
>
> In [12]: arr.dtype.kind
> Out[12]: 'u'
>
> In [13]: arr.dtype.itemsize
> Out[13]: 4
>
> In [14]: arr=N.arange(10,dtype=N.long)
>
> In [15]: arr.dtype.kind
> Out[15]: 'i'
>
> In [16]: arr.dtype.itemsize
> Out[16]: 8

Ack!  That was on the wrong machine (32-bit Debian).  Here is the 64-bit 
version:

In [2]: arr=N.arange(10,dtype=N.uint)

In [3]: arr.dtype.kind
Out[3]: 'u'

In [4]: arr.dtype.itemsize
Out[4]: 8

In [5]: arr=N.arange(10,dtype=N.long)

In [6]: arr.dtype.kind
Out[6]: 'i'

In [7]: arr.dtype.itemsize
Out[7]: 8

Sorry about that,

Scott

-- 
Scott M. Ransom            Address:  NRAO
Phone:  (434) 296-0320               520 Edgemont Rd.
email:  sr...@nr...             Charlottesville, VA 22903 USA
GPG Fingerprint: 06A9 9553 78BE 16DB 407B  FFCA 9BFA B6FF FFD3 2989