The Gaussian hypergeometric function 2F1 is included with other
special functions in the cephes-1.3 package. See
http://pylab.sourceforge.net I haven't used the hypergeometric
function, but the Bessel functions work well with Numerical Python.
-Mark Esplin
---------- Forwarded Message ----------
Subject: [Numpy-discussion] Seeking hypergeometric 2F1 algorithm
Date: Wed, 23 May 2001 10:57:56 -1000
From: "Herbert L. Roitblat" <roitblat(a)hawaii.edu>
To: <numpy-discussion(a)sourceforge.net>
Does anyone have an agorithm for computing the Gaussian hypergeometric
function 2F1 ?
I understand that in principle it should be easy (sum of a series), but
I think that there is a more efficient way to calculate it. My
algorithmic skills are not up to it.
Thanks,
Herb
_______________________________________________
Numpy-discussion mailing list
Numpy-discussion(a)lists.sourceforge.net
http://lists.sourceforge.net/lists/listinfo/numpy-discussion
-------------------------------------------------------
_________________________________________________________
Do You Yahoo!?
Get your free @yahoo.com address at http://mail.yahoo.com
Does anyone have an agorithm for computing the Gaussian hypergeometric
function 2F1 ?
I understand that in principle it should be easy (sum of a series), but I
think that there is a more efficient way to calculate it. My algorithmic
skills are not up to it.
Thanks,
Herb
Hi,
I am trying to install NumPY on my Windows 2000 machine. Could you
please list out the procedure I have to follow to complete the
installation.
Prem.
____________________________________________________________
Prem Rachakonda
____________________________________________________________
Mailing Address: Work Address:
700 Woodland Ave., #E4 Teradyne Connection Systems,
Lexington, Kentucky-40508 44 Simon St., Mail Stop#006,
PH:859-323-2880 Nashua, NewHampshire - 03060
Work Phone No : 603-879-3442
The Program for Climate Model Diagnosis and Intercomparison is pleased to
announce the release of Version 3.0.0 of Climate Data Analysis Tools, an
open-source set of Python modules and tools for accessing, manipulating, and
plotting scientific data in general and climate data sets in particular. The
tools make extensive use of Numerical Python and its optional Masked Arrays
(MA) package and are designed to interoperate with them.
The CDAT website is http://cdat.sf.net, and the SourceForge project page is
http://sf.net/projects/cdat.
Version 3.0.0 is available for Linux and Solaris. Binary distributions are
available for RedHat 6.2, RedHat 7.1, SuSe 7.1, and Solaris 5.6. The user
must have NetCDF and Tcl/Tk installed before using CDAT.
-- Paul Dubois
PCMDI
Lawrence Livermore National Laboratory
Howdy all,
We've got these spiffy comparisons now (thanks Travis et al.!):
] >>> 2 <= arange(8)
] array([0, 0, 1, 1, 1, 1, 1, 1])
but, as noted in the rich comparison PEP, they don't chain:
] >>> 2 <= arange(8) < 6
] array([1, 1, 1, 1, 1, 1, 0, 0])
since
x <= y < z
is equivalent to
x <= y and y < z
and we don't get to overload "and" :-(. But we did overload "&" long ago,
and bitwise_and is equivalent to logical_and if the arguments are only 1
or 0, which is what our comparisons return (I think?). So
(x <= y) & (y < z)
seems like it might be a semi-reasonable substitute, and is shorter and
appeals more to my preferring-operators-over-functions eyes, than
Numeric.logical_and(x <= y, y < z)
(which still beats the ^%$#&^(*&*^ out of
Numeric.logical_and(Numeric.less_equal(x, y), Numeric.less(y, z))
). But I'm a bit squeamish about it. Cons that I see are:
- Do our comparisons really and truly ALWAYS return 1 or 0, even with Infs
and Nans and whatnot?
- It's potentially misleading for readers of the code.
- It just seems kinda wrong, even if it does look better.
So, what think you?
bitwise, bytefoolish-ly y'rs,
Warren Focke
"Paul F. Dubois" wrote:
>> 1) why does the array passed as the first argument to putmask have to be
>> contiguous? this can be a substantial limitation, I end up making copies
>> when I have no other reason to.
> -----> because nobody has implemented the general case; feel free to
> volunteer.
Fair enough. I have yet to open up the NumPy code myself, but I have
written some custom extensions with it, and have a number of small
improvements in mind that I would like to make. Hopefully I will get to
this some day.
> b) No one has gotten around to making the code smart enough to do this
> when it is unambigous.?
> ------> Numpy's attitude toward extra dimensions of length 1 is somewhat
> schizophrenic.
> If you know you want one-d you can put a ravel() around it.
>
> In general the answer to your question is (b) but it is very
> complicated so that is why people don't work on it.
I suspected as much. I'm starting to get used to it. I think my problem
is that I come from MATLAB, where everything is a 2-d array.
Thanks for your comments.
-Chris
--
Christopher Barker,
Ph.D.
ChrisHBarker(a)home.net --- --- ---
http://members.home.net/barkerlohmann ---@@ -----@@ -----@@
------@@@ ------@@@ ------@@@
Oil Spill Modeling ------ @ ------ @ ------ @
Water Resources Engineering ------- --------- --------
Coastal and Fluvial Hydrodynamics --------------------------------------
------------------------------------------------------------------------
Hi,
I've spent several days using the masked arrays that have been added
to NumPy recently. They're a great feature and they were just what I
needed for the little project I was working on (aside from a few bugs
that I found).
However, there were a few things about MA that I found inconvenient
and/or counterintuitive, so I thought I'd post them to the list while
they're fresh in my mind. I'm using Numeric-20.0.0b2.
1. I couldn't find a simple way to tell if all of the cells of a
masked array are unmasked. There are times when you fill an array
incrementally and you want to convert it to a Numeric array but
first make sure that all of the elements have been set.
"m.filled()" is a bit dangerous (in my opinion) because it silently
fills. The shortest idiom I could think of is
>>> assert not logical_or.reduce(ravel(MA.getmaskarray(m)))
which isn't very short :-) and is also awkward because it creates a
mask array even if m.mask() is None. How about a m.is_unmasked()
method, or even giving a special meaning to "m.filled(masked)",
namely that it raises an exception if any cells are still masked.
(As an optimization, this method could set m.__mask = None to speed
up future checks.)
2. I can't reproduce this problem now, but I could swear that the
MaskedArray.__str__() method sometimes printed "typecode='O'" if
masked.enabled() is true. This would be a byproduct of using
Numeric's __str__() method to print the array, at least under the
unknown circumstances in which Numeric.__str__() prints the
typecode. This confused me for a while.
3. I found the semantics of MA.compress(condition,a,axis=0) to be
inconvenient and inconsistent with those of Numeric.compress.
MA.compress() squeezes out not only those elements for which
condition is false, but also those elements that are masked. This
differs from the behavior of Numeric.compress, which always returns
an array with the "axis" dimension equal to the number of nonzero
elements of "condition". The real problem, though, is that
MA.compress can't be used on a multidimensional array with a
nontrivial mask, because squeezing out the masked values is highly
unlikely to result in a rectangular matrix. It is nice to be able
to squeeze masked values out of a 1-d array, but not at the price
of not being able to use compress on a multidimensional array. I
suggest giving MA.compress() semantics closer to those of
Numeric.compress(), and adding an optional argument or a separate
method to cause masked elements to be omitted.
Thanks for a great package!
Yours,
Michael
--
Michael Haggerty
mhagger(a)alum.mit.edu
hi all..
I want to create an array of class objects of size say mXn. What
would be the easiest way to do this?
eg.
class test:
pass
i want 5x10 array of test() instances.
Then only way i know of doing this ,is by creating
a=array(test())
resize(a,[5,10])
but this creates only references to the initial objects.Is there some
way of creating fresh objects ? Also, if the __init__() call of the
class takes some parameters, i should be able to enter values..
thanx in anticipation
ciao
"Paul F. Dubois" <paul(a)pfdubois.com> writes:
> The method __array__(self, typecode=None) is a special (existing)
> hook for conversion to a Numeric array. Many operations in Numeric,
> when presented with an object x to be operated upon, such as
> Numeric.sqrt(x), will call x.__array__ as a final act of desperation
> in an attempt to convert their argument to a Numeric
> array. Heretofore it was essentially returning x.filled(). This
> bothered me, because it was a silent conversion that replaced masked
> values with the fill value.
This bothered me too.
> Solution:
>
> a. Add a method 'unmask()' which will replace the mask by None if
> possible. It will not fail.
>
> b. Change MaskedArray.__array__ to work as follows:
> a. self.unmask(), and then
> b. Return the raw data if the mask is now None.
> Otherwise, throw an MAError.
Perfect. Great solution!
Michael
--
Michael Haggerty
mhagger(a)alum.mit.edu
Paul F. Dubois writes:
> def compress (condition, x, dimension=-1):
> """Select those parts of x for which condition is true.
> Masked values in condition are considered false.
> """
> c = filled(condition, 0)
> m = getmask(x)
> if m is not None:
> m=Numeric.compress(c, m, dimension)
> d = Numeric.compress(c, filled(x), dimension)
> return masked_array(d, m)
>
>
> I did want a treatment of masked conditions. Consider:
>
> compress( x > 10, x)
I see your point, but this doesn't generalize to x having more than
one dimension. And with my semantics, for your example (assuming
1-d), you could substitute
compress((x > 10).filled(0), x)
which isn't very obscure. Moreover, sometimes it is interesting to
compress an array in such a way that masked values are carried along
as masked values; this cannot be done with the existing compress().
Michael
--
Michael Haggerty
mhagger(a)alum.mit.edu
