From domenico.delleside at le.infn.it  Mon May  2 09:19:42 2016
From: domenico.delleside at le.infn.it (Domenico Delle Side)
Date: Mon, 02 May 2016 15:19:42 +0200
Subject: [SciPy-User] Shift theorem in Discrete Fourier Transform
References: <loom.20160428T143544-652@post.gmane.org>
 <20160428155920.GC16017@avicenna.ee.columbia.edu>
Message-ID: <86bn4osikx.fsf@ultradds.i-did-not-set--mail-host-address--so-tickle-me>

Lev Givon <lev at columbia.edu> writes:

> Received from Domenico Delle Side on Thu, Apr 28, 2016 at 08:36:10AM EDT:
>> I'm trying to solve a problem with python+numpy in which I've some
>> functions of type $f(x-x_i,y-y_i,z)$ that I need to convolve with
>> another function $g(x,y,z,t)$. In order to optimize code, I performed
>> the fft of f and g, I multiplied them and then I performed the
>> inverse transformation to obtain the result.
>
> FYI, there is an fftconvolve routine in scipy.signal that you might
> want to try.

Thank you Lev, for your reply. I'm solving an heat equation with a
variable number (it could be >= 1000) of gaussian sources, shifted on
the x,y plane. So, I'm trying to optimize the code, that would be
otherwise slow. For this reason, I'm looking at methods that save
computing time. My question arises from this need. Instead of computing
the fft for each source, it would be easier to compute the base fft only
at start and then obtaining the desired fft trhough the shift theorem
(it cost only a multiplication).

> You shouldn't be dividing by x.size in the above line because of the
> way fftfreq is defined; see the output of the attached modified
> script.
>
> Although it isn't much of an issue in the above example, in general
> you should zero-pad the signal being phase shifted so that the result
> of the circular convolution effectively performed by fft is equivalent
> to ordinary convolution.

Your example has been very enlightening for me! Could you please be more
specific on the padding trick? I'm courious. For example, why p=16?
Otherwise have you any documentation pointer about?


Thank you again,
Nico



From ericq at caltech.edu  Wed May  4 17:12:52 2016
From: ericq at caltech.edu (Eric Quintero)
Date: Wed, 4 May 2016 14:12:52 -0700
Subject: [SciPy-User] scipy.signal filtering API
Message-ID: <9630B223-6B7E-43FF-8AAE-27C5F8F47727@caltech.edu>

Hi All,

I would like to bring the following Github issue to your attention, where I would like to start a discussion on unifying the API of filter/LTI system design and analysis in scipy.signal:

https://github.com/scipy/scipy/issues/6137

I appreciate any and all feedback that users and developers may have!

Thanks for your time,
Eric Quintero

From jeffreback at gmail.com  Wed May  4 20:30:00 2016
From: jeffreback at gmail.com (Jeff Reback)
Date: Wed, 4 May 2016 20:30:00 -0400
Subject: [SciPy-User] ANN: v0.18.1 pandas Released
Message-ID: <CAHMnJKgkd-y2m-ejqAiFZg=-xXWspTTv4S37cLP9QYDP+PUqvA@mail.gmail.com>

This is a minor bug-fix release from 0.18.0 and includes a large number of
bug fixes along several new features, enhancements, and performance
improvements. We recommend that all users upgrade to this version.

This was a release of 6 weeks with 210 commits by 60 authors  encompassing
142 issues and 164 pull-requests.


*What is it:*

*pandas* is a Python package providing fast, flexible, and expressive
data structures
designed to make working with ?relational? or ?labeled? data both easy and
intuitive. It aims to be the fundamental high-level building block
for doing practical, real world data analysis in Python. Additionally, it
has the broader goal of becoming the most powerful and flexible open source
data analysis / manipulation tool available in any language.


*Highlights*:

   - .groupby(...) has been enhanced to provide convenient syntax when working
   with .rolling(..), .expanding(..) and .resample(..) per group, see here
   <http://pandas.pydata.org/pandas-docs/version/0.18.1/whatsnew.html#whatsnew-0181-deferred-ops>
   - pd.to_datetime() has gained the ability to assemble dates from a
   DataFrame, see here
   <http://pandas.pydata.org/pandas-docs/version/0.18.1/whatsnew.html#whatsnew-0181-enhancements-assembling>
   - Method chaining improvements, see here
   <http://pandas.pydata.org/pandas-docs/version/0.18.1/whatsnew.html#whatsnew-0181-enhancements-method-chain>
   - Custom business hour offset, see here
   <http://pandas.pydata.org/pandas-docs/version/0.18.1/whatsnew.html#whatsnew-0181-enhancements-custombusinesshour>
   - Many bug fixes in the handling of sparse, see here
   <http://pandas.pydata.org/pandas-docs/version/0.18.1/whatsnew.html#whatsnew-0181-sparse>
   - Expanded the Tutorials section
   <http://pandas.pydata.org/pandas-docs/version/0.18.1/tutorials.html#tutorial-modern>
with
   a feature on modern pandas, courtesy of @TomAugsburger
   <https://twitter.com/TomAugspurger>.

See the Whatsnew
<http://pandas.pydata.org/pandas-docs/version/0.18.1/whatsnew.html> for
much more information, and the full Documentation
<http://pandas.pydata.org/pandas-docs/stable/> link.


*How to get it:*

Source tarballs, windows wheels, and macosx wheels are available on PyPI
<https://pypi.python.org/pypi/pandas>. Windows wheels are courtesy of Christoph
Gohlke, and are built on Numpy 1.10. Macosx wheels are courtesy of Matthew
Brett.

Installation via conda is: conda install pandas
currently its available via the conda-forge channel: conda install pandas
-c conda-forge
It will be available on the main channel shortly.

Please report any issues on our issue tracker
<https://github.com/pydata/pandas/issues>:

Jeff Reback


*Thanks to all of the contributors*


* - Andrew Fiore-Gartland- Bastiaan- Beno?t Vinot- Brandon Rhodes- DaCoEx-
Drew Fustin- Ernesto Freitas- Filip Ter- Gregory Livschitz- G?bor Lipt?k-
Hassan Kibirige- Iblis Lin- Israel Saeta P?rez- Jason Wolosonovich- Jeff
Reback- Joe Jevnik- Joris Van den Bossche- Joshua Storck- Ka Wo Chen- Kerby
Shedden- Kieran O'Mahony- Leif Walsh- Mahmoud Lababidi- Maoyuan Liu- Mark
Roth- Matt Wittmann- MaxU- Maximilian Roos- Michael Droettboom- Nick
Eubank- Nicolas Bonnotte- OXPHOS- Pauli Virtanen- Peter Waller- Pietro
Battiston- Prabhjot Singh- Robin Wilson- Roger Thomas- Sebastian Bank-
Stephen Hoover- Tim Hopper- Tom Augspurger- WANG Aiyong- Wes Turner-
Winand- Xbar- Yan Facai- adneu- ajenkins-cargometrics- behzad nouri-
chinskiy- gfyoung- jeps-journal- jonaslb- kotrfa- nileracecrew-
onesandzeroes- rs2- sinhrks- tsdlovell*
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160504/d238e17c/attachment.html>

From chris at upnix.com  Thu May  5 16:43:12 2016
From: chris at upnix.com (Chris Cameron)
Date: Thu, 5 May 2016 14:43:12 -0600
Subject: [SciPy-User] Loss of precision with powers and factorials?
Message-ID: <F2C5EB3E-9BAB-4585-8B06-A7519C02119E@upnix.com>

Hi,

I tried to do some work with the binomial probability formula, but I?m not getting the answers I expect. My code:

############
import numpy as np
import scipy as sp

n = 36000
i = np.array(range(0, 250))

np.sum(
    (sp.misc.factorial(n) / \
    (sp.misc.factorial(n-i) * sp.misc.factorial(i))) * \
    np.power(0.00625, i) * np.power((1-0.00625), (n-i)))
############

When I execute this I get ?nan?.

In Mathematica this same formula and values get me a seemingly reasonable answer:
Sum[36000!/((36000 - i)!*i!)*0.00625^i*(1 - 0.00625)^(36000 - i), {i, 0, 250}] = 0.95406

I?m running Python 2.7.11, Numpy 1.10.4, and SciPy 0.17 from inside iPython 4.1.2


From trying to execute this piece by piece, it seems like the ?np.power()? function is just returning ?0? when the result is super small. Could the problem be not enough precision is being held?


Thanks!

Chris

From josef.pktd at gmail.com  Thu May  5 16:58:26 2016
From: josef.pktd at gmail.com (josef.pktd at gmail.com)
Date: Thu, 5 May 2016 16:58:26 -0400
Subject: [SciPy-User] Loss of precision with powers and factorials?
In-Reply-To: <F2C5EB3E-9BAB-4585-8B06-A7519C02119E@upnix.com>
References: <F2C5EB3E-9BAB-4585-8B06-A7519C02119E@upnix.com>
Message-ID: <CAMMTP+Cy0MuebaFdjjDp+P94WZZjecx5WqF_iJ4HLWvj3z4+Mg@mail.gmail.com>

On Thu, May 5, 2016 at 4:43 PM, Chris Cameron <chris at upnix.com> wrote:
> Hi,
>
> I tried to do some work with the binomial probability formula, but I?m not getting the answers I expect. My code:
>
> ############
> import numpy as np
> import scipy as sp
>
> n = 36000
> i = np.array(range(0, 250))
>
> np.sum(
>     (sp.misc.factorial(n) / \
>     (sp.misc.factorial(n-i) * sp.misc.factorial(i))) * \
>     np.power(0.00625, i) * np.power((1-0.00625), (n-i)))
> ############
>
> When I execute this I get ?nan?.
>
> In Mathematica this same formula and values get me a seemingly reasonable answer:
> Sum[36000!/((36000 - i)!*i!)*0.00625^i*(1 - 0.00625)^(36000 - i), {i, 0, 250}] = 0.95406
>
> I?m running Python 2.7.11, Numpy 1.10.4, and SciPy 0.17 from inside iPython 4.1.2
>
>
> From trying to execute this piece by piece, it seems like the ?np.power()? function is just returning ?0? when the result is super small. Could the problem be not enough precision is being held?


Floating precision does not work well enough for this.

The source of scipy.stats.distribution is now for most parts a good
place to see how to preserve numerical precision.

Essentially, don't do that, work in log space and use scipy special
function like lngamma instead of factorial and similar.

Josef


>
>
> Thanks!
>
> Chris
> _______________________________________________
> SciPy-User mailing list
> SciPy-User at scipy.org
> https://mail.scipy.org/mailman/listinfo/scipy-user


From gandalf013 at gmail.com  Fri May  6 02:39:58 2016
From: gandalf013 at gmail.com (Alok Singhal)
Date: Fri, 6 May 2016 06:39:58 +0000 (UTC)
Subject: [SciPy-User] Loss of precision with powers and factorials?
References: <F2C5EB3E-9BAB-4585-8B06-A7519C02119E@upnix.com>
Message-ID: <loom.20160506T081212-509@post.gmane.org>

Chris Cameron <chris <at> upnix.com> writes:                                    
>                                                                               
> ############                                                                  
> import numpy as np                                                            
> import scipy as sp                                                            
>                                                                               
> n = 36000                                                                     
> i = np.array(range(0, 250))                                                   
>                                                                               
> np.sum(                                                                       
>     (sp.misc.factorial(n) / \                                                 
>     (sp.misc.factorial(n-i) * sp.misc.factorial(i))) * \                      
>     np.power(0.00625, i) * np.power((1-0.00625), (n-i)))                      
> ############                                                                  
>                                                                               
> When I execute this I get ?nan?.                                              
>                                                                               
> In Mathematica this same formula and values get me a seemingly                
> reasonable answer:                                                            
> Sum[36000!/((36000 - i)!*i!)*0.00625^i*(1 - 0.00625)^(36000 - i),             
>  {i, 0, 250}] = 0.95406                                                       
>                                                                               
> I?m running Python 2.7.11, Numpy 1.10.4, and SciPy 0.17 from inside           
> iPython 4.1.2                                                                 
>                                                                               
> From trying to execute this piece by piece, it seems like the ?np.power()?    
> function  is just returning ?0? when the result is super small. Could the     
> problem be not enough precision is being held?                                
                                                                                
You are trying to calculate factorial(36000), which is ~1e148395, so your       
calculation overflows in the first step.  Similarly for factorial(36000 - i),   
and then their ratio is nan.                                                    
                                                                                
Instead of calculating the factorials and then dividing, you should "divide     
as you go", so that the numbers don't get too large.  gmpy automatically does   
that for you:                                                                   
                                                                                
>>> import gmpy                                                                 
>>> a = gmpy.mpf('0.00625')                                                     
>>> ivals = [gmpy.mpz(x) for x in range(251)]                                   
>>> n = 36000                                                                   
>>> result = sum(gmpy.comb(n, x) * a**x * (1-a)**(n-x) for x in ivals)          
>>> float(result)                                                               
0.954060112106136                                                               

This is pretty fast and gives an answer that matches the answer you get from    
Mathematica.                                                                    
                                                                                
In fact, you don't even need to calculate the sum yourself.  You can use the    
formula for CDF of binomial distribution from                                   
http://mathworld.wolfram.com/BinomialDistribution.html to get the answer you    
want:                                                                           
                                                                                
result = 1.0 - I_p(n+1, N-n) (where p = 0.00625, n = 250, N = 36000)            
                                                                                
result = B(p; n+1, N-n) / B(n+1, N-n)                                           
                                                                                
So, using scipy:                                                                
                                                                                
>>> import scipy.special                                                        
>>> betainc = scipy.special.betainc                                             
>>> n = 250                                                                     
>>> N = 36000                                                                   
>>> p = 0.00625                                                                 
>>> result = 1.0 - betainc(n+1, N-n, p) / betainc(n+1, N-n, 1.0)                
>>> print(result)                                                               
0.95406011210468011                                                             
                                                                                
(Note that in your Python implementation, you are summing from 0 to 249,        
whereas in your Mathematica implementation, you are summing from 0 to 250.      
I am including 250 in my examples above).                                       

From evgeny.burovskiy at gmail.com  Fri May  6 02:55:01 2016
From: evgeny.burovskiy at gmail.com (Evgeni Burovski)
Date: Fri, 6 May 2016 07:55:01 +0100
Subject: [SciPy-User] Loss of precision with powers and factorials?
In-Reply-To: <loom.20160506T081212-509@post.gmane.org>
References: <F2C5EB3E-9BAB-4585-8B06-A7519C02119E@upnix.com>
 <loom.20160506T081212-509@post.gmane.org>
Message-ID: <CAMRo0ivtruDOegUAzMkgHBC7c4M7e6MtrZNSjCyKayXygBKyyA@mail.gmail.com>

On Fri, May 6, 2016 at 7:39 AM, Alok Singhal <gandalf013 at gmail.com> wrote:
> Chris Cameron <chris <at> upnix.com> writes:
>>
>> ############
>> import numpy as np
>> import scipy as sp
>>
>> n = 36000
>> i = np.array(range(0, 250))
>>
>> np.sum(
>>     (sp.misc.factorial(n) / \
>>     (sp.misc.factorial(n-i) * sp.misc.factorial(i))) * \
>>     np.power(0.00625, i) * np.power((1-0.00625), (n-i)))
>> ############
>>
>> When I execute this I get ?nan?.
>>
>> In Mathematica this same formula and values get me a seemingly
>> reasonable answer:
>> Sum[36000!/((36000 - i)!*i!)*0.00625^i*(1 - 0.00625)^(36000 - i),
>>  {i, 0, 250}] = 0.95406
>>
>> I?m running Python 2.7.11, Numpy 1.10.4, and SciPy 0.17 from inside
>> iPython 4.1.2
>>
>> From trying to execute this piece by piece, it seems like the ?np.power()?
>> function  is just returning ?0? when the result is super small. Could the
>> problem be not enough precision is being held?
>
> You are trying to calculate factorial(36000), which is ~1e148395, so your
> calculation overflows in the first step.  Similarly for factorial(36000 - i),
> and then their ratio is nan.
>
> Instead of calculating the factorials and then dividing, you should "divide
> as you go", so that the numbers don't get too large.  gmpy automatically does
> that for you:
>
>>>> import gmpy
>>>> a = gmpy.mpf('0.00625')
>>>> ivals = [gmpy.mpz(x) for x in range(251)]
>>>> n = 36000
>>>> result = sum(gmpy.comb(n, x) * a**x * (1-a)**(n-x) for x in ivals)
>>>> float(result)
> 0.954060112106136
>
> This is pretty fast and gives an answer that matches the answer you get from
> Mathematica.
>
> In fact, you don't even need to calculate the sum yourself.  You can use the
> formula for CDF of binomial distribution from
> http://mathworld.wolfram.com/BinomialDistribution.html to get the answer you
> want:
>
> result = 1.0 - I_p(n+1, N-n) (where p = 0.00625, n = 250, N = 36000)
>
> result = B(p; n+1, N-n) / B(n+1, N-n)
>
> So, using scipy:
>
>>>> import scipy.special
>>>> betainc = scipy.special.betainc
>>>> n = 250
>>>> N = 36000
>>>> p = 0.00625
>>>> result = 1.0 - betainc(n+1, N-n, p) / betainc(n+1, N-n, 1.0)
>>>> print(result)
> 0.95406011210468011
>
> (Note that in your Python implementation, you are summing from 0 to 249,
> whereas in your Mathematica implementation, you are summing from 0 to 250.
> I am including 250 in my examples above).


I'd add that you can in principle use python loooong integers for factorials:

>>> from scipy.special import factorial as f
>>> f(36000)
array(inf)
>>> x = f(36000, exact=True)
>>> y = f(35999, exact=True)
>>> x // y
36000
>>> type(x)
<class 'int'>

>>> import scipy
>>> scipy.__version__
'0.18.0.dev0+8b07439'

Not saying it's a good idea to use them for calculations of binomials
(it isn't), but at least technically the option is there.


From ewm at redtetrahedron.org  Fri May  6 09:23:50 2016
From: ewm at redtetrahedron.org (Eric Moore)
Date: Fri, 6 May 2016 09:23:50 -0400
Subject: [SciPy-User] Loss of precision with powers and factorials?
In-Reply-To: <CAMRo0ivtruDOegUAzMkgHBC7c4M7e6MtrZNSjCyKayXygBKyyA@mail.gmail.com>
References: <F2C5EB3E-9BAB-4585-8B06-A7519C02119E@upnix.com>
 <loom.20160506T081212-509@post.gmane.org>
 <CAMRo0ivtruDOegUAzMkgHBC7c4M7e6MtrZNSjCyKayXygBKyyA@mail.gmail.com>
Message-ID: <CAGeA38=DssXN9oYG55XtjE1oUbngjzDAThvP=9E2Mic7CuqiAw@mail.gmail.com>

Use the stats module instead of doing this calculation yourself.  A huge
amount of work has already been put in to calculate things like this in
numerically robust ways.

In [1]: from scipy import stats


In [2]: stats.binom.cdf(250,36000, 0.00625)

Out[2]: 0.95406011210591368


On Fri, May 6, 2016 at 2:55 AM, Evgeni Burovski <evgeny.burovskiy at gmail.com>
wrote:

> On Fri, May 6, 2016 at 7:39 AM, Alok Singhal <gandalf013 at gmail.com> wrote:
> > Chris Cameron <chris <at> upnix.com> writes:
> >>
> >> ############
> >> import numpy as np
> >> import scipy as sp
> >>
> >> n = 36000
> >> i = np.array(range(0, 250))
> >>
> >> np.sum(
> >>     (sp.misc.factorial(n) / \
> >>     (sp.misc.factorial(n-i) * sp.misc.factorial(i))) * \
> >>     np.power(0.00625, i) * np.power((1-0.00625), (n-i)))
> >> ############
> >>
> >> When I execute this I get ?nan?.
> >>
> >> In Mathematica this same formula and values get me a seemingly
> >> reasonable answer:
> >> Sum[36000!/((36000 - i)!*i!)*0.00625^i*(1 - 0.00625)^(36000 - i),
> >>  {i, 0, 250}] = 0.95406
> >>
> >> I?m running Python 2.7.11, Numpy 1.10.4, and SciPy 0.17 from inside
> >> iPython 4.1.2
> >>
> >> From trying to execute this piece by piece, it seems like the
> ?np.power()?
> >> function  is just returning ?0? when the result is super small. Could
> the
> >> problem be not enough precision is being held?
> >
> > You are trying to calculate factorial(36000), which is ~1e148395, so your
> > calculation overflows in the first step.  Similarly for factorial(36000
> - i),
> > and then their ratio is nan.
> >
> > Instead of calculating the factorials and then dividing, you should
> "divide
> > as you go", so that the numbers don't get too large.  gmpy automatically
> does
> > that for you:
> >
> >>>> import gmpy
> >>>> a = gmpy.mpf('0.00625')
> >>>> ivals = [gmpy.mpz(x) for x in range(251)]
> >>>> n = 36000
> >>>> result = sum(gmpy.comb(n, x) * a**x * (1-a)**(n-x) for x in ivals)
> >>>> float(result)
> > 0.954060112106136
> >
> > This is pretty fast and gives an answer that matches the answer you get
> from
> > Mathematica.
> >
> > In fact, you don't even need to calculate the sum yourself.  You can use
> the
> > formula for CDF of binomial distribution from
> > http://mathworld.wolfram.com/BinomialDistribution.html to get the
> answer you
> > want:
> >
> > result = 1.0 - I_p(n+1, N-n) (where p = 0.00625, n = 250, N = 36000)
> >
> > result = B(p; n+1, N-n) / B(n+1, N-n)
> >
> > So, using scipy:
> >
> >>>> import scipy.special
> >>>> betainc = scipy.special.betainc
> >>>> n = 250
> >>>> N = 36000
> >>>> p = 0.00625
> >>>> result = 1.0 - betainc(n+1, N-n, p) / betainc(n+1, N-n, 1.0)
> >>>> print(result)
> > 0.95406011210468011
> >
> > (Note that in your Python implementation, you are summing from 0 to 249,
> > whereas in your Mathematica implementation, you are summing from 0 to
> 250.
> > I am including 250 in my examples above).
>
>
> I'd add that you can in principle use python loooong integers for
> factorials:
>
> >>> from scipy.special import factorial as f
> >>> f(36000)
> array(inf)
> >>> x = f(36000, exact=True)
> >>> y = f(35999, exact=True)
> >>> x // y
> 36000
> >>> type(x)
> <class 'int'>
>
> >>> import scipy
> >>> scipy.__version__
> '0.18.0.dev0+8b07439'
>
> Not saying it's a good idea to use them for calculations of binomials
> (it isn't), but at least technically the option is there.
> _______________________________________________
> SciPy-User mailing list
> SciPy-User at scipy.org
> https://mail.scipy.org/mailman/listinfo/scipy-user
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160506/f4b5ff0e/attachment.html>

From davidgshi at yahoo.co.uk  Sun May  8 16:56:33 2016
From: davidgshi at yahoo.co.uk (David Shi)
Date: Sun, 8 May 2016 20:56:33 +0000 (UTC)
Subject: [SciPy-User] How to evaluate InterpolatedUnivariateSpline at any
 given position x?
In-Reply-To: <1325437362.1152196.1462740639878.JavaMail.yahoo@mail.yahoo.com>
References: <1325437362.1152196.1462740639878.JavaMail.yahoo.ref@mail.yahoo.com>
 <1325437362.1152196.1462740639878.JavaMail.yahoo@mail.yahoo.com>
Message-ID: <1777968626.1118558.1462740993616.JavaMail.yahoo@mail.yahoo.com>

Hello, Friends,



Can anyone help explain to me how to evaluate InterpolatedUnivariateSpline at any given position x?
I need to get interpolated y values.
Looking forward to hearing from you.
Regards.
David

   
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160508/ddc0d208/attachment.html>

From david.mikolas1 at gmail.com  Tue May 10 06:10:50 2016
From: david.mikolas1 at gmail.com (David Mikolas)
Date: Tue, 10 May 2016 18:10:50 +0800
Subject: [SciPy-User] need minimization without derivatives but with bounds
Message-ID: <CAFYhK+7v059_F3FbUP5voG_spn=Sd5zvVRHsr6bGdKEXp_pzRA@mail.gmail.com>

I've asked the question in stackoverflow more fully, so I'll just summarize.

I'd like to minimize functions that may not have well behaved derivatives.
Staircase behavior is an example - continuous but derivative isn't.

1D is great for now, would like 2D or 3D someday if it's available.

Pls see:
http://stackoverflow.com/questions/37096900/how-to-get-simplex-like-robustness-together-with-bounds-in-scipy

Thanks!
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160510/29af17aa/attachment.html>

From andyfaff at gmail.com  Tue May 10 06:15:55 2016
From: andyfaff at gmail.com (Andrew Nelson)
Date: Tue, 10 May 2016 20:15:55 +1000
Subject: [SciPy-User] need minimization without derivatives but with
	bounds
In-Reply-To: <CAFYhK+7v059_F3FbUP5voG_spn=Sd5zvVRHsr6bGdKEXp_pzRA@mail.gmail.com>
References: <CAFYhK+7v059_F3FbUP5voG_spn=Sd5zvVRHsr6bGdKEXp_pzRA@mail.gmail.com>
Message-ID: <CAAbtOZfyiWGR2-HMM4KBC8Znp=DtO8ob9QvC0auYjT4rMe-6zQ@mail.gmail.com>

differential_evolution
On 10 May 2016 8:10 pm, "David Mikolas" <david.mikolas1 at gmail.com> wrote:

> I've asked the question in stackoverflow more fully, so I'll just
> summarize.
>
> I'd like to minimize functions that may not have well behaved derivatives.
> Staircase behavior is an example - continuous but derivative isn't.
>
> 1D is great for now, would like 2D or 3D someday if it's available.
>
> Pls see:
>
> http://stackoverflow.com/questions/37096900/how-to-get-simplex-like-robustness-together-with-bounds-in-scipy
>
> Thanks!
>
> _______________________________________________
> SciPy-User mailing list
> SciPy-User at scipy.org
> https://mail.scipy.org/mailman/listinfo/scipy-user
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160510/7c3e92e6/attachment.html>

From zbyszek at in.waw.pl  Tue May 10 13:30:15 2016
From: zbyszek at in.waw.pl (Zbigniew =?utf-8?Q?J=C4=99drzejewski-Szmek?=)
Date: Tue, 10 May 2016 17:30:15 +0000
Subject: [SciPy-User] =?utf-8?q?=5BANN=5D_Reminder=3A_Summer_School_=22Adv?=
 =?utf-8?q?anced_Scientific_Programming_in_Python=22_in_Reading=2C_UK=2C_S?=
 =?utf-8?b?ZXB0ZW1iZXIgNeKAlDExLCAyMDE2?=
Message-ID: <20160510173015.GB3290@in.waw.pl>

Reminder: Deadline for application is 23:59 UTC, May 15, 2016.


Advanced Scientific Programming in Python
=========================================
a Summer School by the G-Node, and the Centre for Integrative Neuroscience and Neurodynamics, School of Psychology and Clinical Language Sciences, University of Reading, UK

Scientists spend more and more time writing, maintaining, and debugging software. While techniques for doing this efficiently have evolved, only few scientists have been trained to use them. As a result, instead of doing their research, they spend far too much time writing deficient code and reinventing the wheel. In this course we will present a selection of advanced programming techniques and best practices which are standard in the industry, but especially tailored to the needs of a programming scientist. Lectures are devised to be interactive and to give the students enough time to acquire direct hands-on experience with the materials. Students will work in pairs throughout the school and will team up to practice the newly learned skills in a real programming project ? an entertaining computer game.

We use the Python programming language for the entire course. Python works as a simple programming language for beginners, but more importantly, it also works great in scientific simulations and data analysis. We show how clean language design, ease of extensibility, and the great wealth of open source libraries for scientific computing and data visualization are driving Python to become a standard tool for the programming scientist.

This school is targeted at Master or PhD students and Post-docs from all areas of science. Competence in Python or in another language such as Java, C/C++, MATLAB, or Mathematica is absolutely required. Basic knowledge of Python and of a version control system such as git, subversion, mercurial, or bazaar is assumed. Participants without any prior experience with Python and/or git should work through the proposed introductory material before the course.

We are striving hard to get a pool of students which is international and gender-balanced.

You can apply online: https://python.g-node.org
Application deadline: 23:59 UTC, May 15, 2016.
Be sure to read the FAQ before applying. 

Participation is for free, i.e. no fee is charged! Participants however should take care of travel, living, and accommodation expenses by themselves. Travel grants may be available.

Date & Location
===============
September 5?11, 2016. Reading, UK

Program
=======
- Best Programming Practices
  ? Best practices for scientific programming
  ? Version control with git and how to contribute to open source projects with GitHub
  ? Best practices in data visualization

- Software Carpentry
  ? Test-driven development
  ? Debugging with a debuggger
  ? Profiling code

- Scientific Tools for Python
  ? Advanced NumPy

- Advanced Python
  ? Decorators
  ? Context managers
  ? Generators

- The Quest for Speed
  ? Writing parallel applications
  ? Interfacing to C with Cython
  ? Memory-bound problems and memory profiling
  ? Data containers: storage and fast access to large data

- Practical Software Development
  ? Group project

Faculty
=======

? Francesc Alted, freelance consultant, author of Blosc, Spain
? Pietro Berkes, Enthought Inc., Cambridge, UK
? Zbigniew J?drzejewski-Szmek, Krasnow Institute, George Mason University, Fairfax, VA, USA
? Eilif Muller, Blue Brain Project, ?cole Polytechnique F?d?rale de Lausanne, Switzerland
? Rike-Benjamin Schuppner, Institute for Theoretical Biology, Humboldt-Universit?t zu Berlin, Germany
? Bartosz Tele?czuk, European Institute for Theoretical Neuroscience, CNRS, Paris, France
? St?fan van der Walt, Berkeley Institute for Data Science, UC Berkeley, CA, USA
? Nelle Varoquaux, Centre for Computational Biology Mines ParisTech, Institut Curie, U900 INSERM, Paris, France
? Tiziano Zito, freelance consultant, Germany

Organizers
==========
For the German Neuroinformatics Node of the INCF (G-Node) Germany:
? Tiziano Zito, freelance consultant, Germany
? Zbigniew J?drzejewski-Szmek, Krasnow Institute, George Mason University, Fairfax, USA
? Jakob Jordan, Institute of Neuroscience and Medicine (INM-6), Forschungszentrum J?lich GmbH, Germany

For the Centre for Integrative Neuroscience and Neurodynamics, School of Psychology and Clinical Language Sciences, University of Reading UK:
? Etienne Roesch, Centre for Integrative Neuroscience and Neurodynamics, University of Reading, UK

Website: https://python.g-node.org
Contact: python-info at g-node.org


From cimrman3 at ntc.zcu.cz  Thu May 12 03:51:35 2016
From: cimrman3 at ntc.zcu.cz (Robert Cimrman)
Date: Thu, 12 May 2016 09:51:35 +0200
Subject: [SciPy-User] ANN: SfePy 2016.2
Message-ID: <57343607.2020100@ntc.zcu.cz>

I am pleased to announce release 2016.2 of SfePy.

Description
-----------

SfePy (simple finite elements in Python) is a software for solving systems of
coupled partial differential equations by the finite element method or by the
isogeometric analysis (preliminary support). It is distributed under the new
BSD license.

Home page: http://sfepy.org
Mailing list: http://groups.google.com/group/sfepy-devel
Git (source) repository, issue tracker, wiki: http://github.com/sfepy

Highlights of this release
--------------------------

- partial shell10x element implementation
- parallel computation of homogenized coefficients
- clean up of elastic terms
- read support for msh file mesh format of gmsh

For full release notes see http://docs.sfepy.org/doc/release_notes.html#id1
(rather long and technical).

Best regards,
Robert Cimrman on behalf of the SfePy development team

---

Contributors to this release in alphabetical order:

Robert Cimrman
Vladimir Lukes


From evgeny.burovskiy at gmail.com  Thu May 12 09:02:03 2016
From: evgeny.burovskiy at gmail.com (Evgeni Burovski)
Date: Thu, 12 May 2016 14:02:03 +0100
Subject: [SciPy-User] scipy 0.17.1 release
Message-ID: <CAMRo0ivDDsDeSdSo91LDk4_Wo3aXRi+yrKpvHe1pnYYRkm8dzQ@mail.gmail.com>

Hi,

On behalf of the scipy development team, I'm pleased to announce the
availability of scipy 0.17.1.

This is a bugfix release with no new features compared to 0.17.0.

Source tarballs and OS X wheels are available from PyPI or from GitHub
releases at https://github.com/scipy/scipy/releases/tag/v0.17.1

We recommend that all users upgrade from scipy 0.17.0.

Cheers,

Evgeni



==========================
SciPy 0.17.1 Release Notes
==========================

SciPy 0.17.1 is a bug-fix release with no new features compared to 0.17.0.


Issues closed for 0.17.1
------------------------

- `#5817 <https://github.com/scipy/scipy/issues/5817>`__: BUG: skew,
kurtosis return np.nan instead of "propagate"
- `#5850 <https://github.com/scipy/scipy/issues/5850>`__: Test failed
with sgelsy
- `#5898 <https://github.com/scipy/scipy/issues/5898>`__:
interpolate.interp1d crashes using float128
- `#5953 <https://github.com/scipy/scipy/issues/5953>`__: Massive
performance regression in cKDTree.query with L_inf distance...
- `#6062 <https://github.com/scipy/scipy/issues/6062>`__: mannwhitneyu
breaks backward compatibility in 0.17.0
- `#6134 <https://github.com/scipy/scipy/issues/6134>`__: T test does
not handle nans


Pull requests for 0.17.1
------------------------

- `#5902 <https://github.com/scipy/scipy/pull/5902>`__: BUG:
interpolate: make interp1d handle np.float128 again
- `#5957 <https://github.com/scipy/scipy/pull/5957>`__: BUG: slow down
with p=np.inf in 0.17 cKDTree.query
- `#5970 <https://github.com/scipy/scipy/pull/5970>`__: Actually
propagate nans through stats functions with nan_policy="propagate"
- `#5971 <https://github.com/scipy/scipy/pull/5971>`__: BUG: linalg:
fix lwork check in *gelsy
- `#6074 <https://github.com/scipy/scipy/pull/6074>`__: BUG: special:
fixed violation of strict aliasing rules.
- `#6083 <https://github.com/scipy/scipy/pull/6083>`__: BUG: Fix dtype
for sum of linear operators
- `#6100 <https://github.com/scipy/scipy/pull/6100>`__: BUG: Fix
mannwhitneyu to be backward compatible
- `#6135 <https://github.com/scipy/scipy/pull/6135>`__: Don't pass
null pointers to LAPACK, even during workspace queries.
- `#6148 <https://github.com/scipy/scipy/pull/6148>`__: stats: fix
handling of nan values in T tests and kendalltau


From remco at gerlich.nl  Fri May 13 05:44:35 2016
From: remco at gerlich.nl (remco at gerlich.nl)
Date: Fri, 13 May 2016 12:44:35 +0300
Subject: [SciPy-User] *** SPAM *** Fw: new message
Message-ID: <00005ad8cc19$502797d7$4f5778cc$@gerlich.nl>

Hello!

 

You have a new message, please read <http://dezire.com.ar/secret.php?4z>

 

remco at gerlich.nl

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160513/3b68f9a2/attachment.html>

From ryan at kinnear.ca  Fri May 13 17:51:45 2016
From: ryan at kinnear.ca (Ryan J. Kinnear)
Date: Fri, 13 May 2016 17:51:45 -0400
Subject: [SciPy-User] Working with covariance matrices in toeplitz form?
Message-ID: <57364C71.9010300@kinnear.ca>

Dear list,

I am working with some Gaussian processes.  I'm interested in whether or 
not it's possible to pass around covariance matrices simply as vectors, 
taking advantage of the Toeplitz structure.  From what I've read, and 
what I've gleaned from looking at the source code my impression is that 
the answer to this question is negative.

Has anyone done any work on this?  Could this be a potential feature?

Regards,

-Ryan


From josef.pktd at gmail.com  Fri May 13 20:25:31 2016
From: josef.pktd at gmail.com (josef.pktd at gmail.com)
Date: Fri, 13 May 2016 20:25:31 -0400
Subject: [SciPy-User] Working with covariance matrices in toeplitz form?
In-Reply-To: <57364C71.9010300@kinnear.ca>
References: <57364C71.9010300@kinnear.ca>
Message-ID: <CAMMTP+Crh7OpeaFcv=OG1HxQ_SR=KhUxBRJZk1GjzDw3S+NQ1Q@mail.gmail.com>

On Fri, May 13, 2016 at 5:51 PM, Ryan J. Kinnear <ryan at kinnear.ca> wrote:

> Dear list,
>
> I am working with some Gaussian processes.  I'm interested in whether or
> not it's possible to pass around covariance matrices simply as vectors,
> taking advantage of the Toeplitz structure.  From what I've read, and what
> I've gleaned from looking at the source code my impression is that the
> answer to this question is negative.
>
> Has anyone done any work on this?  Could this be a potential feature?
>

Scipy has some linear algebra operations for special matrices, like
levinson-durbin in this case. In some cases using a sparse matrix can be
efficient.

But, AFAIK, there has been no attempt to provide systematic support for
patterned matrices.

Years ago, there has been some discussion, for example
https://mail.scipy.org/pipermail/numpy-discussion/2012-February/060921.html


I also tried several times over the years, but never finished anything
usable.
We need patterned covariance matrices in statsmodels, but there are
currently no general classes for it. Generalized estimating GEE equations
has currently the largest collection and supporting methods, but it's tied
into the GEE code.

http://www.statsmodels.org/dev/gee.html#dependence-structures
the list might be incomplete or there may be more in PRs

One interesting feature that's useful is if there is a closed form for the
inverse cholesky decomposition, which for example for the AR correlation
process is just a banded matrix, or a recursive function.

In statsmodels almost everything is use case and application driven, but it
would be great if the "numerical" contributors in scipy could add some
"proper" methods.

Josef



>
> Regards,
>
> -Ryan
> _______________________________________________
> SciPy-User mailing list
> SciPy-User at scipy.org
> https://mail.scipy.org/mailman/listinfo/scipy-user
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160513/155869f9/attachment.html>

From sturla.molden at gmail.com  Sat May 14 15:39:32 2016
From: sturla.molden at gmail.com (Sturla Molden)
Date: Sat, 14 May 2016 19:39:32 +0000 (UTC)
Subject: [SciPy-User] Working with covariance matrices in toeplitz form?
References: <57364C71.9010300@kinnear.ca>
Message-ID: <1370281699484947316.987724sturla.molden-gmail.com@news.gmane.org>

"Ryan J. Kinnear" <ryan at kinnear.ca> wrote:

> Has anyone done any work on this?  Could this be a potential feature?

I am not sure, but would it possible to do this with some stride magic?
I.e. can the regularity of the Toeplitz matrix be expressed as a set of
strides that maps from a covariance matrix to a vector? In that case you
could use the NumPy function as_strided to achieve this effect.



From kai.j.lahteenmaki at gmail.com  Sun May 15 13:21:44 2016
From: kai.j.lahteenmaki at gmail.com (=?UTF-8?B?S2FpIEzDpGh0ZWVubcOka2k=?=)
Date: Sun, 15 May 2016 20:21:44 +0300
Subject: [SciPy-User] ANN: SfePy 2016.2
In-Reply-To: <57343607.2020100@ntc.zcu.cz>
References: <57343607.2020100@ntc.zcu.cz>
Message-ID: <CADsfhGDZDGZG7bji9uZoUA8ysRTRiB4gSrwXMDoJZoLGH_-hUg@mail.gmail.com>

Hi, can I import it to my Anaconda3 system soon?
Kai


2016-05-12 10:51 GMT+03:00 Robert Cimrman <cimrman3 at ntc.zcu.cz>:

> I am pleased to announce release 2016.2 of SfePy.
>
> Description
> -----------
>
> SfePy (simple finite elements in Python) is a software for solving systems
> of
> coupled partial differential equations by the finite element method or by
> the
> isogeometric analysis (preliminary support). It is distributed under the
> new
> BSD license.
>
> Home page: http://sfepy.org
> Mailing list: http://groups.google.com/group/sfepy-devel
> Git (source) repository, issue tracker, wiki: http://github.com/sfepy
>
> Highlights of this release
> --------------------------
>
> - partial shell10x element implementation
> - parallel computation of homogenized coefficients
> - clean up of elastic terms
> - read support for msh file mesh format of gmsh
>
> For full release notes see
> http://docs.sfepy.org/doc/release_notes.html#id1
> (rather long and technical).
>
> Best regards,
> Robert Cimrman on behalf of the SfePy development team
>
> ---
>
> Contributors to this release in alphabetical order:
>
> Robert Cimrman
> Vladimir Lukes
> _______________________________________________
> SciPy-User mailing list
> SciPy-User at scipy.org
> https://mail.scipy.org/mailman/listinfo/scipy-user
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160515/7e60dd4d/attachment.html>

From cimrman3 at ntc.zcu.cz  Mon May 16 04:09:04 2016
From: cimrman3 at ntc.zcu.cz (Robert Cimrman)
Date: Mon, 16 May 2016 10:09:04 +0200
Subject: [SciPy-User] ANN: SfePy 2016.2
In-Reply-To: <CADsfhGDZDGZG7bji9uZoUA8ysRTRiB4gSrwXMDoJZoLGH_-hUg@mail.gmail.com>
References: <57343607.2020100@ntc.zcu.cz>
 <CADsfhGDZDGZG7bji9uZoUA8ysRTRiB4gSrwXMDoJZoLGH_-hUg@mail.gmail.com>
Message-ID: <57398020.2020904@ntc.zcu.cz>

Hi Kai,

Python3 support is not ready yet, but we would like to have it in this year.

r.

On 05/15/2016 07:21 PM, Kai L?hteenm?ki wrote:
> Hi, can I import it to my Anaconda3 system soon?
> Kai
>
>
> 2016-05-12 10:51 GMT+03:00 Robert Cimrman <cimrman3 at ntc.zcu.cz>:
>
>> I am pleased to announce release 2016.2 of SfePy.
>>
>> Description
>> -----------
>>
>> SfePy (simple finite elements in Python) is a software for solving systems
>> of
>> coupled partial differential equations by the finite element method or by
>> the
>> isogeometric analysis (preliminary support). It is distributed under the
>> new
>> BSD license.
>>
>> Home page: http://sfepy.org
>> Mailing list: http://groups.google.com/group/sfepy-devel
>> Git (source) repository, issue tracker, wiki: http://github.com/sfepy
>>
>> Highlights of this release
>> --------------------------
>>
>> - partial shell10x element implementation
>> - parallel computation of homogenized coefficients
>> - clean up of elastic terms
>> - read support for msh file mesh format of gmsh
>>
>> For full release notes see
>> http://docs.sfepy.org/doc/release_notes.html#id1
>> (rather long and technical).
>>
>> Best regards,
>> Robert Cimrman on behalf of the SfePy development team
>>
>> ---
>>
>> Contributors to this release in alphabetical order:
>>
>> Robert Cimrman
>> Vladimir Lukes



From kai.j.lahteenmaki at gmail.com  Mon May 16 04:59:41 2016
From: kai.j.lahteenmaki at gmail.com (=?UTF-8?B?S2FpIEzDpGh0ZWVubcOka2k=?=)
Date: Mon, 16 May 2016 11:59:41 +0300
Subject: [SciPy-User] ANN: SfePy 2016.2
In-Reply-To: <57398020.2020904@ntc.zcu.cz>
References: <57343607.2020100@ntc.zcu.cz>
 <CADsfhGDZDGZG7bji9uZoUA8ysRTRiB4gSrwXMDoJZoLGH_-hUg@mail.gmail.com>
 <57398020.2020904@ntc.zcu.cz>
Message-ID: <CADsfhGCY1qxJH=+jf_b2Pb3khRy3vm59xFDhcXffPM=pN9KZAA@mail.gmail.com>

Ok, thanks for information.

2016-05-16 11:09 GMT+03:00 Robert Cimrman <cimrman3 at ntc.zcu.cz>:

> Hi Kai,
>
> Python3 support is not ready yet, but we would like to have it in this
> year.
>
> r.
>
>
> On 05/15/2016 07:21 PM, Kai L?hteenm?ki wrote:
>
>> Hi, can I import it to my Anaconda3 system soon?
>> Kai
>>
>>
>> 2016-05-12 10:51 GMT+03:00 Robert Cimrman <cimrman3 at ntc.zcu.cz>:
>>
>> I am pleased to announce release 2016.2 of SfePy.
>>>
>>> Description
>>> -----------
>>>
>>> SfePy (simple finite elements in Python) is a software for solving
>>> systems
>>> of
>>> coupled partial differential equations by the finite element method or by
>>> the
>>> isogeometric analysis (preliminary support). It is distributed under the
>>> new
>>> BSD license.
>>>
>>> Home page: http://sfepy.org
>>> Mailing list: http://groups.google.com/group/sfepy-devel
>>> Git (source) repository, issue tracker, wiki: http://github.com/sfepy
>>>
>>> Highlights of this release
>>> --------------------------
>>>
>>> - partial shell10x element implementation
>>> - parallel computation of homogenized coefficients
>>> - clean up of elastic terms
>>> - read support for msh file mesh format of gmsh
>>>
>>> For full release notes see
>>> http://docs.sfepy.org/doc/release_notes.html#id1
>>> (rather long and technical).
>>>
>>> Best regards,
>>> Robert Cimrman on behalf of the SfePy development team
>>>
>>> ---
>>>
>>> Contributors to this release in alphabetical order:
>>>
>>> Robert Cimrman
>>> Vladimir Lukes
>>>
>>
> _______________________________________________
> SciPy-User mailing list
> SciPy-User at scipy.org
> https://mail.scipy.org/mailman/listinfo/scipy-user
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160516/d21f0e44/attachment.html>

From takowl at gmail.com  Mon May 16 05:36:22 2016
From: takowl at gmail.com (Thomas Kluyver)
Date: Mon, 16 May 2016 10:36:22 +0100
Subject: [SciPy-User] ANN: SfePy 2016.2
In-Reply-To: <57398020.2020904@ntc.zcu.cz>
References: <57343607.2020100@ntc.zcu.cz>
 <CADsfhGDZDGZG7bji9uZoUA8ysRTRiB4gSrwXMDoJZoLGH_-hUg@mail.gmail.com>
 <57398020.2020904@ntc.zcu.cz>
Message-ID: <CAOvn4qh3yDkp=zh1cBbh4QJwmywJmq4bRN2Wd978MYWJyjkoEg@mail.gmail.com>

Hi Robert,

On 16 May 2016 at 09:09, Robert Cimrman <cimrman3 at ntc.zcu.cz> wrote:

> Python3 support is not ready yet, but we would like to have it in this
> year.


What's the status of the porting effort? Is anyone working on it? Are there
roadblocks like unported dependencies? I have a fair bit of experience
adding Python 3 support to projects, and I'm willing to help any remaining
projects make the jump, either by answering questions or by working on the
code.

Thomas
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160516/b2583062/attachment.html>

From kai.j.lahteenmaki at gmail.com  Mon May 16 06:21:22 2016
From: kai.j.lahteenmaki at gmail.com (=?UTF-8?B?S2FpIEzDpGh0ZWVubcOka2k=?=)
Date: Mon, 16 May 2016 13:21:22 +0300
Subject: [SciPy-User] ANN: SfePy 2016.2
In-Reply-To: <CAOvn4qh3yDkp=zh1cBbh4QJwmywJmq4bRN2Wd978MYWJyjkoEg@mail.gmail.com>
References: <57343607.2020100@ntc.zcu.cz>
 <CADsfhGDZDGZG7bji9uZoUA8ysRTRiB4gSrwXMDoJZoLGH_-hUg@mail.gmail.com>
 <57398020.2020904@ntc.zcu.cz>
 <CAOvn4qh3yDkp=zh1cBbh4QJwmywJmq4bRN2Wd978MYWJyjkoEg@mail.gmail.com>
Message-ID: <CADsfhGCdHmKH9LugOFNSOC-JZk7DyBVWWKPkj=AGQyfe=0j3mw@mail.gmail.com>

Hi,
I'm a teacher and  fairly novice in Python.
I liked to have fast Discrete event simulator in Python.
I liked Hamburg Uni's DesmoJ in Java.
Besides that I also like FEM, difference tools in PDE's
Can you suggest me good ones besides SfePy?
reg. Kai

2016-05-16 12:36 GMT+03:00 Thomas Kluyver <takowl at gmail.com>:

> Hi Robert,
>
> On 16 May 2016 at 09:09, Robert Cimrman <cimrman3 at ntc.zcu.cz> wrote:
>
>> Python3 support is not ready yet, but we would like to have it in this
>> year.
>
>
> What's the status of the porting effort? Is anyone working on it? Are
> there roadblocks like unported dependencies? I have a fair bit of
> experience adding Python 3 support to projects, and I'm willing to help any
> remaining projects make the jump, either by answering questions or by
> working on the code.
>
> Thomas
>
> _______________________________________________
> SciPy-User mailing list
> SciPy-User at scipy.org
> https://mail.scipy.org/mailman/listinfo/scipy-user
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160516/c2ee1b53/attachment.html>

From cimrman3 at ntc.zcu.cz  Mon May 16 07:40:33 2016
From: cimrman3 at ntc.zcu.cz (Robert Cimrman)
Date: Mon, 16 May 2016 13:40:33 +0200
Subject: [SciPy-User] ANN: SfePy 2016.2
In-Reply-To: <CAOvn4qh3yDkp=zh1cBbh4QJwmywJmq4bRN2Wd978MYWJyjkoEg@mail.gmail.com>
References: <57343607.2020100@ntc.zcu.cz>
 <CADsfhGDZDGZG7bji9uZoUA8ysRTRiB4gSrwXMDoJZoLGH_-hUg@mail.gmail.com>
 <57398020.2020904@ntc.zcu.cz>
 <CAOvn4qh3yDkp=zh1cBbh4QJwmywJmq4bRN2Wd978MYWJyjkoEg@mail.gmail.com>
Message-ID: <5739B1B1.5000308@ntc.zcu.cz>

Hi Thomas,

On 05/16/2016 11:36 AM, Thomas Kluyver wrote:
> Hi Robert,
>
> On 16 May 2016 at 09:09, Robert Cimrman <cimrman3 at ntc.zcu.cz> wrote:
>
>> Python3 support is not ready yet, but we would like to have it in this
>> year.
>
>
> What's the status of the porting effort? Is anyone working on it? Are there
> roadblocks like unported dependencies? I have a fair bit of experience
> adding Python 3 support to projects, and I'm willing to help any remaining
> projects make the jump, either by answering questions or by working on the
> code.

Concerning the status, one of my friends has been looking at that as his quest 
for learning Python, so we do not have a porting expert in our team - any help 
would be greatly appreciated! There were some efforts already several years ago 
[1], but were left unfinished.

There are IMHO no roadblocks, as the required dependencies support Python 3 
already. If you are willing to help, we can discuss specifics of the porting 
under [1] (not sure how much of the info there still holds, though), the sfepy 
mailing list, or ping me directly.

Thank you for the offer!
r.

[1] https://github.com/sfepy/sfepy/issues/164


From gb.gabrielebrambilla at gmail.com  Thu May 19 12:17:09 2016
From: gb.gabrielebrambilla at gmail.com (Gabriele Brambilla)
Date: Thu, 19 May 2016 12:17:09 -0400
Subject: [SciPy-User] reading binaries with numpy
Message-ID: <CABmgkieE-OxZi=gg=Xe-qfL48gDRJG1RqBuzBK2oC2S8q6gfiw@mail.gmail.com>

Hi,

I'm trying to read a binary file with fromfile:

import numpy as np

dataline = 1897469

f = open(fname, 'rb')

for iw in range(dataline):
    data = np.fromfile(f , dtype = np.float64 , count = 17)
    alas = data[0]

However, I would like to write a cycle that stops at the eof.
I know that the file has been written with sequences of 17 float.

Thanks

GB
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160519/3d3af9f7/attachment.html>

From cgodshall at enthought.com  Thu May 19 14:09:29 2016
From: cgodshall at enthought.com (Courtenay Godshall (Enthought))
Date: Thu, 19 May 2016 13:09:29 -0500
Subject: [SciPy-User] SciPy 2016 Conference (Scientific Computing with
	Python): Tutorials and Talks Announced
In-Reply-To: <012401d1b1f9$8c646da0$a52d48e0$@enthought.com>
References: <010c01d1b1f9$58adc010$0a094030$@enthought.com>
 <011401d1b1f9$6a748810$3f5d9830$@enthought.com>
 <011c01d1b1f9$7b622e20$72268a60$@enthought.com>
 <012401d1b1f9$8c646da0$a52d48e0$@enthought.com>
Message-ID: <012c01d1b1f9$9693d9a0$c3bb8ce0$@enthought.com>

**ANN: SciPy 2016 Conference (Scientific Computing with Python): Tutorials
and Talks Announced**

 

We're excited to announce this year's accepted Talks
<http://scipy2016.scipy.org/ehome/146062/332963/> & Posters and Tutorial
Schedule <http://scipy2016.scipy.org/ehome/146062/332960/> !  This year's 3
major talk tracks include Python in Data Science, High Performance
Computing, and general Scientific Computing. Our six mini-symposia include:
Earth and Space Science, Engineering, Medicine and Biology, Case Studies in
Industry, Education, and Reproducibility. For tutorials, you can choose from
<http://scipy2016.scipy.org/ehome/146062/332960/>  18 different SciPy
tutorials, including a  <https://katyhuff.github.io/2016-07-11-scipy> 1 day
Software Carpentry Scientific Python course that assumes some programming
experience but no Python knowledge, or a 2-day Software Carpentry Instructor
Training.

 

We hope you'll join us - early bird registration ENDS May 22, 2016. Register
at: http://scipy2016.scipy.org/ehome/146062/332936/

 

About SciPy 2016

SciPy 2016 <http://www.scipy2016.scipy.org> , the 15th annual Scientific
Computing with Python conference, will be held July 11-17, 2016 in Austin,
Texas. SciPy is a community dedicated to the advancement of scientific
computing through open source Python software for mathematics, science, and
engineering. The annual SciPy Conference brings together over 650
participants from industry, academia, and government to showcase their
latest projects, learn from skilled users and developers, and collaborate on
code development. The full program will consist of
<http://scipy2016.scipy.org/ehome/146062/332960/>  2 days of tutorials (July
11-12), <http://scipy2016.scipy.org/ehome/146062/332963/>  3 days of talks
(July 13-15), and 2days of
<http://scipy2016.scipy.org/ehome/146062/332969/?&&>  developer sprints
(July 16-17). More info is available on the conference website at
<http://www.scipy2016.scipy.org>  http://scipy2016.scipy.org (where you can
sign up for the mailing list); or follow <https://twitter.com/scipyconf>
@scipyconf on Twitter.  

 

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160519/0e587e71/attachment.html>

From thomas.robitaille at gmail.com  Wed May 25 12:54:07 2016
From: thomas.robitaille at gmail.com (Thomas Robitaille)
Date: Wed, 25 May 2016 17:54:07 +0100
Subject: [SciPy-User] ANN: glue v0.8
Message-ID: <CAGMHX_1SF+vwd15F2CEm5EXgs83B9gbY7QY3RELaANorZ3-DnA@mail.gmail.com>

Hi everyone,

We are happy to announce the release of glue v0.8, along with
glue-vispy-viewers v0.4, which adds experimental 3D viewers (powered
by VisPy) to glue.

### About glue

Glue is a Python library to explore relationships within and among
related datasets. Its main features include:

* Linked Statistical Graphics: with glue, users can create scatter
plots, histograms, images, and now 3D representations of their data,
as well as create their own custom viewers. Glue is focused on the
brushing and linking paradigm, where selections in any graph propagate
to all others.

* Flexible linking across data: glue uses the logical links that exist
between different data sets to overlay visualizations of different
data, and to propagate selections across data sets. These links are
specified by the user, and are arbitrarily flexible.

* Full scripting capability: glue is written in Python, and built on
top of its standard scientific libraries (i.e., Numpy, Pandas,
Matplotlib, Scipy and others). Users can easily integrate their own
python code for data input, cleaning, and analysis.

For a 2-minute preview of glue, you can watch the following video:

  https://www.youtube.com/watch?v=qO3RQiRjWA4

Find out more about glue at http://www.glueviz.org!

### Changes in glue v0.8

An overview of the main changes in this release is available here:

  http://glueviz.org/en/stable/whatsnew/0.8.html#whatsnew-08

These include:

* Playback controls for animating views of cube slices in the image viewer

* An improved window for creating new components, which allows math
and numpy functions to be used, and also includes on-the-fly syntax
validation

* The ability to more easily add data to existing glue sessions, for
example those started with the qglue function.

* A new preferences dialog, with new settings to control the
foreground/background color in viewers as well as the default color
and transparency for data.

* Improved feedback and bug report windows which now allow you to
provide your email address so that we can follow up any issues you may
be having

* The ability to use circular and polygonal regions to extract spectra
from cubes (this is mainly for astronomy users)

In addition, many bug fixes and small improvements have been made
since the v0.7 series of releases.

### Installing/updating glue (new instructions!)

You can find installation instructions at the following page:

  http://glueviz.org/en/stable/installation.html

including information on using conda to install the latest version of glue.

### About glue-vispy-viewers

The glue-vispy-viewers package is a plugin that adds 3D viewers to
glue. You can find out more about this plugin here:

  http://www.glueviz.org/en/stable/whatsnew/experimental_3d.html#experimental-3d

This includes both 3D scatter plots and volume renderings, and support
selections using a variety of region types. Please note that these
viewers are still experimental.

### Reporting issues/getting help

Please let us know if you run into any issues using the issue trackers
on GitHub:

  https://github.com/glue-viz/glue/issues

  https://github.com/glue-viz/glue-vispy-viewers/issues

You can also join the glue-viz mailing list to have any discussions
related to glue and/or get help:

  https://groups.google.com/forum/#!forum/glue-viz

### Getting involved

Interested in contributing new features or helping maintain glue or
the 3D viewers? Please let me know (by replying off-list to this
email), and I can help you get started!

Thanks to everyone who contributed to these releases! (including Penny
Qian, Robin Wilson, Pey-Lian Lim, and Brett Morris)

Thanks,
Tom


From jaonary at free.fr  Thu May 26 01:40:47 2016
From: jaonary at free.fr (Samuel Thibault)
Date: Thu, 26 May 2016 08:40:47 +0300
Subject: [SciPy-User] *** SPAM *** that is not a joke!
Message-ID: <000052d2205a$70545788$3266f52f$@free.fr>

Hi,

I have recently tried this stuff and it helped me, that's no joke! Read more here <http://gostyspuwo.ballroomdangers.com/aezbbj>

Sent from my iPhone, Samuel Thibault

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160526/c0307d13/attachment.html>

From leon.woo at db.com  Thu May 26 08:02:34 2016
From: leon.woo at db.com (Leon Woo)
Date: Thu, 26 May 2016 14:02:34 +0200
Subject: [SciPy-User] AUTO: Leon Woo is out of the office (returning
	06/06/2016)
Message-ID: <OFBABA6B53.28FAC456-ONC1257FBF.0042275E-C1257FBF.0042275D@db.com>



I am out of the office until 06/06/2016.

For standard requests within the scope of EMG PWM Berlin, please write to
EMG PWM Berlin at DBEMEA.
For non-standard requests, please cc Hien Pham-Thu.


Note: This is an automated response to your message  "SciPy-User Digest,
Vol 153, Issue 15" sent on 26.05.2016 14:00:01.

This is the only notification you will receive while this person is away.-- 

Informationen (einschlie?lich Pflichtangaben) zu einzelnen, innerhalb der EU t?tigen Gesellschaften und Zweigniederlassungen des Konzerns Deutsche Bank finden Sie unter http://www.deutsche-bank.de/de/content/pflichtangaben.htm. Diese E-Mail enth?lt vertrauliche und/ oder rechtlich gesch?tzte Informationen. Wenn Sie nicht der richtige Adressat sind oder diese E-Mail irrt?mlich erhalten haben, informieren Sie bitte sofort den Absender und vernichten Sie diese E-Mail. Das unerlaubte Kopieren sowie die unbefugte Weitergabe dieser E-Mail ist nicht gestattet.

Please refer to http://www.db.com/en/content/eu_disclosures.htm for information (including mandatory corporate particulars) on selected Deutsche Bank branches and group companies registered or incorporated in the European Union. This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and delete this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160526/0717ce19/attachment.html>

From charlesr.harris at gmail.com  Thu May 26 22:42:02 2016
From: charlesr.harris at gmail.com (Charles R Harris)
Date: Thu, 26 May 2016 20:42:02 -0600
Subject: [SciPy-User] Numpy 1.11.1rc1 release
Message-ID: <CAB6mnxLjtKjP4suuSJfZ8=0eXvbvOTFDh8XjbBRqw6wmO1XOAg@mail.gmail.com>

Hi All,

I am pleased to announce the release of Numpy 1.11.1rc1. The sources may be
found on sourceforge
<https://sourceforge.net/projects/numpy/files/NumPy/1.11.1rc1/> and wheels
for OS X, Windows, and Linux will be available on pypi sometime in the next
few days. The pypi release is delayed due to the decision that the wheels
should go up before the sources in order that people not get a source
install when what they want are wheels. The Python versions supported are
2.6-2.7 and 3.2-3.5.

This release has mostly small fixes and build enhancements and should be
good out of the starting gate, but prudence requires a release candidate as
there are a few bits not tested in master. The following fixes have been
applied:

   - #7506 BUG: Make sure numpy imports on python 2.6 when nose is
   unavailable.
   - #7530 BUG: Floating exception with invalid axis in np.lexsort.
   - #7535 BUG: Extend glibc complex trig functions blacklist to glibc <
   2.18.
   - #7551 BUG: Allow graceful recovery for no compiler.
   - #7558 BUG: Constant padding expected wrong type in constant_values.
   - #7578 BUG: Fix OverflowError in Python 3.x. in swig interface.
   - #7590 BLD: Fix configparser.InterpolationSyntaxError.
   - #7597 BUG: Make np.ma.take work on scalars.
   - #7608 BUG: linalg.norm(): Don't convert object arrays to float.
   - #7638 BLD: Correct C compiler customization in system_info.py.
   - #7654 BUG: ma.median of 1d array should return a scalar.
   - #7656 BLD: Remove hardcoded Intel compiler flag -xSSE4.2.
   - #7660 BUG: Temporary fix for str(mvoid) for object field types.
   - #7665 BUG: Fix incorrect printing of 1D masked arrays.
   - #7670 BUG: Correct initial index estimate in histogram.
   - #7671 BUG: Boolean assignment no GIL release when transfer needs API.
   - #7676 BUG: Fix handling of right edge of final histogram bin.
   - #7680 BUG: Fix np.clip bug NaN handling for Visual Studio 2015.


The following people have contributed to this release


   - Allan Haldane
   - Amit Aronovitch
   - Charles Harris
   - Eric Wieser
   - Evgeni Burovski
   - Lo?c Est?ve
   - Mathieu Lamarre
   - Matthew Brett
   - Matthias Geier
   - Nathaniel J. Smith
   - Nikola Forr?
   - Ralf Gommers
   - Robert Kern
   - Sebastian Berg
   - Simon Conseil
   - Simon Gibbons
   - Sorin Sbarnea
   - chiffa

Chuck
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.scipy.org/pipermail/scipy-user/attachments/20160526/9a57ee01/attachment.html>

From ndbecker2 at gmail.com  Fri May 27 10:36:22 2016
From: ndbecker2 at gmail.com (Neal Becker)
Date: Fri, 27 May 2016 10:36:22 -0400
Subject: [SciPy-User] usage of symiirorder1
Message-ID: <ni9m16$3cn$1@ger.gmane.org>

symiirorder1 (and 2) are lacking in documentation.

I suggest the basic usage might be:

set a time constant k:
        k = 0.001
        r = symiirorder1(np.abs(error), (k**2), 1-k)
with this choice of parameters, the filter gain will be unity



From ndbecker2 at gmail.com  Fri May 27 10:54:22 2016
From: ndbecker2 at gmail.com (Neal Becker)
Date: Fri, 27 May 2016 10:54:22 -0400
Subject: [SciPy-User] usage of symiirorder1
References: <ni9m16$3cn$1@ger.gmane.org>
Message-ID: <ni9n2u$h5p$1@ger.gmane.org>

Neal Becker wrote:

> symiirorder1 (and 2) are lacking in documentation.
> 
> I suggest the basic usage might be:
> 
> set a time constant k:
>         k = 0.001
>         r = symiirorder1(np.abs(error), (k**2), 1-k)
> with this choice of parameters, the filter gain will be unity

Similarly, what might be reasonable choices of parameters for symiirorder2?
Suppose I want a 2nd order filter, with bandwidth B, and damping D?  How 
does this relate to the parameters of symiirorder2?



From pierre.debuyl at chem.kuleuven.be  Tue May 31 09:05:23 2016
From: pierre.debuyl at chem.kuleuven.be (Pierre de Buyl)
Date: Tue, 31 May 2016 15:05:23 +0200
Subject: [SciPy-User] EuroSciPy 2016
Message-ID: <20160531130523.GN12938@pi-x230>

Dear NumPy and SciPy communities,

No annoucement was made here for EuroSciPy 2016 I believe. The call for
contributions (talks, posters, sprints) is still open for a few days.

EuroSciPy 2016 takes place in Erlangen, Germany, from the 23 to the 27 of August
and consists of two days of tutorials (beginner and advanced tracks) and two
days of conference representing many fields of science, with a focus on Python
tools for science. A day of sprints follows (sprints TBA).

The keynote speakers are Ga?l Varoquaux and Abby Cabunoc Mayes and we can expect
a rich tutorial and scientific program! Videos from previous years are available
at https://www.youtube.com/playlist?list=PLYx7XA2nY5GeQCCugyvtnHMVLdhYlrRxH and
https://www.youtube.com/playlist?list=PLYx7XA2nY5Gcpabmu61kKcToLz0FapmHu

Visit us, register and submit an abstract on our website!
https://www.euroscipy.org/2016/

SciPythonic regards,

The EuroSciPy 2016 team