From pav at iki.fi Sat May 5 14:36:03 2018 From: pav at iki.fi (Pauli Virtanen) Date: Sat, 05 May 2018 20:36:03 +0200 Subject: [SciPy-User] ANN: SciPy 1.1.0 released Message-ID: <236a10a327111484ffc775d388704ebcca6500a7.camel@iki.fi> -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Hi all, On behalf of the SciPy development team I'm pleased to announce the SciPy 1.1.0 release. Sources and binary wheels can be found at https://pypi.python.org/pypi/scipy and at https://github.com/scipy/scipy/releases/tag/v1.1.0. To install with pip: pip install scipy==1.1.0 Thanks to everyone who contributed to this release! ========================= SciPy 1.1.0 Release Notes ========================= SciPy 1.1.0 is the culmination of 7 months of hard work. It contains many new features, numerous bug-fixes, improved test coverage and better documentation. There have been a number of deprecations and API changes in this release, which are documented below. All users are encouraged to upgrade to this release, as there are a large number of bug-fixes and optimizations. Before upgrading, we recommend that users check that their own code does not use deprecated SciPy functionality (to do so, run your code with ``python -Wd`` and check for ``DeprecationWarning`` s). Our development attention will now shift to bug-fix releases on the 1.1.x branch, and on adding new features on the master branch. This release requires Python 2.7 or 3.4+ and NumPy 1.8.2 or greater. This release has improved but not necessarily 100% compatibility with the `PyPy `__ Python implementation. For running on PyPy, PyPy 6.0+ and Numpy 1.15.0+ are required. New features ============ `scipy.integrate` improvements - ------------------------------ The argument ``tfirst`` has been added to the function `scipy.integrate.odeint`. This allows odeint to use the same user functions as `scipy.integrate.solve_ivp` and `scipy.integrate.ode` without the need for wrapping them in a function that swaps the first two arguments. Error messages from ``quad()`` are now clearer. `scipy.linalg` improvements - --------------------------- The function `scipy.linalg.ldl` has been added for factorization of indefinite symmetric/hermitian matrices into triangular and block diagonal matrices. Python wrappers for LAPACK ``sygst``, ``hegst`` added in `scipy.linalg.lapack`. Added `scipy.linalg.null_space`, `scipy.linalg.cdf2rdf`, `scipy.linalg.rsf2csf`. `scipy.misc` improvements - ------------------------- An electrocardiogram has been added as an example dataset for a one-dimensional signal. It can be accessed through `scipy.misc.electrocardiogram`. `scipy.ndimage` improvements - ---------------------------- The routines `scipy.ndimage.binary_opening`, and `scipy.ndimage.binary_closing` now support masks and different border values. `scipy.optimize` improvements - ----------------------------- The method ``trust-constr`` has been added to `scipy.optimize.minimize`. The method switches between two implementations depending on the problem definition. For equality constrained problems it is an implementation of a trust-region sequential quadratic programming solver and, when inequality constraints are imposed, it switches to a trust-region interior point method. Both methods are appropriate for large scale problems. Quasi-Newton options BFGS and SR1 were implemented and can be used to approximate second order derivatives for this new method. Also, finite-differences can be used to approximate either first-order or second-order derivatives. Random-to-Best/1/bin and Random-to-Best/1/exp mutation strategies were added to `scipy.optimize.differential_evolution` as ``randtobest1bin`` and ``randtobest1exp``, respectively. Note: These names were already in use but implemented a different mutation strategy. See `Backwards incompatible changes <#backwards-incompatible-changes>`__, below. The ``init`` keyword for the `scipy.optimize.differential_evolution` function can now accept an array. This array allows the user to specify the entire population. Add an ``adaptive`` option to Nelder-Mead to use step parameters adapted to the dimensionality of the problem. Minor improvements in `scipy.optimize.basinhopping`. `scipy.signal` improvements - --------------------------- Three new functions for peak finding in one-dimensional arrays were added. `scipy.signal.find_peaks` searches for peaks (local maxima) based on simple value comparison of neighbouring samples and returns those peaks whose properties match optionally specified conditions for their height, prominence, width, threshold and distance to each other. `scipy.signal.peak_prominences` and `scipy.signal.peak_widths` can directly calculate the prominences or widths of known peaks. Added ZPK versions of frequency transformations: `scipy.signal.bilinear_zpk`, `scipy.signal.lp2bp_zpk`, `scipy.signal.lp2bs_zpk`, `scipy.signal.lp2hp_zpk`, `scipy.signal.lp2lp_zpk`. Added `scipy.signal.windows.dpss`, `scipy.signal.windows.general_cosine` and `scipy.signal.windows.general_hamming`. `scipy.sparse` improvements - --------------------------- Previously, the ``reshape`` method only worked on `scipy.sparse.lil_matrix`, and in-place reshaping did not work on any matrices. Both operations are now implemented for all matrices. Handling of shapes has been made consistent with ``numpy.matrix`` throughout the `scipy.sparse` module (shape can be a tuple or splatted, negative number acts as placeholder, padding and unpadding dimensions of size 1 to ensure length-2 shape). `scipy.special` improvements - ---------------------------- Added Owen?s T function as `scipy.special.owens_t`. Accuracy improvements in ``chndtr``, ``digamma``, ``gammaincinv``, ``lambertw``, ``zetac``. `scipy.stats` improvements - -------------------------- The Moyal distribution has been added as `scipy.stats.moyal`. Added the normal inverse Gaussian distribution as `scipy.stats.norminvgauss`. Deprecated features =================== The iterative linear equation solvers in `scipy.sparse.linalg` had a sub-optimal way of how absolute tolerance is considered. The default behavior will be changed in a future Scipy release to a more standard and less surprising one. To silence deprecation warnings, set the ``atol=`` parameter explicitly. `scipy.signal.windows.slepian` is deprecated, replaced by `scipy.signal.windows.dpss`. The window functions in `scipy.signal` are now available in `scipy.signal.windows`. They will remain also available in the old location in the `scipy.signal` namespace in future Scipy versions. However, importing them from `scipy.signal.windows` is preferred, and new window functions will be added only there. Indexing sparse matrices with floating-point numbers instead of integers is deprecated. The function `scipy.stats.itemfreq` is deprecated. Backwards incompatible changes ============================== Previously, `scipy.linalg.orth` used a singular value cutoff value appropriate for double precision numbers also for single-precision input. The cutoff value is now tunable, and the default has been changed to depend on the input data precision. In previous versions of Scipy, the ``randtobest1bin`` and ``randtobest1exp`` mutation strategies in `scipy.optimize.differential_evolution` were actually implemented using the Current-to-Best/1/bin and Current-to-Best/1/exp strategies, respectively. These strategies were renamed to ``currenttobest1bin`` and ``currenttobest1exp`` and the implementations of ``randtobest1bin`` and ``randtobest1exp`` strategies were corrected. Functions in the ndimage module now always return their output array. Before this most functions only returned the output array if it had been allocated by the function, and would return ``None`` if it had been provided by the user. Distance metrics in `scipy.spatial.distance` now require non-negative weights. `scipy.special.loggamma` returns now real-valued result when the input is real-valued. Other changes ============= When building on Linux with GNU compilers, the ``.so`` Python extension files now hide all symbols except those required by Python, which can avoid problems when embedding the Python interpreter. Authors ======= * Saurabh Agarwal + * Diogo Aguiam + * Joseph Albert + * Gerrit Ansmann + * Jean-Fran?ois B + * Vahan Babayan + * Alessandro Pietro Bardelli * Christoph Baumgarten + * Felix Berkenkamp * Lilian Besson + * Aditya Bharti + * Matthew Brett * Evgeni Burovski * CJ Carey * Martin ?. Christensen + * Robert Cimrman * Vicky Close + * Peter Cock + * Philip DeBoer * Jaime Fernandez del Rio * Dieter Werthm?ller + * Tom Donoghue + * Matt Dzugan + * Lars G + * Jacques Gaudin + * Andriy Gelman + * Sean Gillies + * Dezmond Goff * Christoph Gohlke * Ralf Gommers * Uri Goren + * Deepak Kumar Gouda + * Douglas Lessa Graciosa + * Matt Haberland * David Hagen * Charles Harris * Jordan Heemskerk + * Danny Hermes + * Stephan Hoyer + * Theodore Hu + * Jean-Fran?ois B. + * Mads Jensen + * Jon Haitz Legarreta Gorro?o + * Ben Jude + * Noel Kippers + * Julius Bier Kirkegaard + * Maria Knorps + * Mikkel Kristensen + * Eric Larson * Kasper Primdal Lauritzen + * Denis Laxalde * KangWon Lee + * Jan Lehky + * Jackie Leng + * P.L. Lim + * Nikolay Mayorov * Mihai Capot? + * Max Mikhaylov + * Mark Mikofski + * Jarrod Millman * Raden Muhammad + * Paul Nation * Andrew Nelson * Nico Schl?mer * Joel Nothman * Kyle Oman + * Egor Panfilov + * Nick Papior * Anubhav Patel + * Oleksandr Pavlyk * Ilhan Polat * Robert Pollak + * Anant Prakash + * Aman Pratik * Sean Quinn + * Giftlin Rajaiah + * Tyler Reddy * Joscha Reimer * Antonio H Ribeiro + * Antonio Horta Ribeiro * Benjamin Rose + * Fabian Rost * Divakar Roy + * Scott Sievert * Leo Singer * Sourav Singh * Martino Sorbaro + * Eric Stansifer + * Martin Thoma * Phil Tooley + * Piotr Uchwat + * Paul van Mulbregt * Pauli Virtanen * Stefan van der Walt * Warren Weckesser * Florian Weimer + * Eric Wieser * Josh Wilson * Ted Ying + * Evgeny Zhurko * Z? Vin?cius * @Astrofysicus + * @awakenting + * @endolith * @FormerPhysicist + * @gaulinmp + * @hugovk * @ksemb + * @kshitij12345 + * @luzpaz + * @NKrvavica + * @rafalalgo + * @samyak0210 + * @soluwalana + * @sudheerachary + * @Tokixix + * @tttthomasssss + * @vkk800 + * @xoviat * @ziejcow + A total of 122 people contributed to this release. People with a "+" by their names contributed a patch for the first time. This list of names is automatically generated, and may not be fully complete. Issues closed for 1.1.0 - ----------------------- * `#979 `__: Allow Hermitian matrices in lobpcg (Trac #452) * `#2694 `__: Solution of iterative solvers can be less accurate than tolerance... * `#3164 `__: RectBivariateSpline usage inconsistent with other interpolation... * `#4161 `__: Missing ITMAX optional argument in scipy.optimize.nnls * `#4354 `__: signal.slepian should use definition of digital window * `#4866 `__: Shouldn't scipy.linalg.sqrtm raise an error if matrix is singular? * `#4953 `__: The dirichlet distribution unnecessarily requires strictly positive... * `#5336 `__: sqrtm on a diagonal matrix can warn "Matrix is singular and may... * `#5922 `__: Suboptimal convergence of Halley's method? * `#6036 `__: Incorrect edge case in scipy.stats.triang.pdf * `#6202 `__: Enhancement: Add LDLt factorization to scipy * `#6589 `__: sparse.random with custom rvs callable does pass on arg to subclass * `#6654 `__: Spearman's rank correlation coefficient slow with nan values... * `#6794 `__: Remove NumarrayType struct with numarray type names from ndimage * `#7136 `__: The dirichlet distribution unnecessarily rejects probabilities... * `#7169 `__: Will it be possible to add LDL' factorization for Hermitian indefinite... * `#7291 `__: fsolve docs should say it doesn't handle over- or under-determined... * `#7453 `__: binary_opening/binary_closing missing arguments * `#7500 `__: linalg.solve test failure on OS X with Accelerate * `#7555 `__: Integratig a function with singularities using the quad routine * `#7624 `__: allow setting both absolute and relative tolerance of sparse... * `#7724 `__: odeint documentation refers to t0 instead of t * `#7746 `__: False CDF values for skew normal distribution * `#7750 `__: mstats.winsorize documentation needs clarification * `#7787 `__: Documentation error in spherical Bessel, Neumann, modified spherical... * `#7836 `__: Scipy mmwrite incorrectly writes the zeros for skew-symmetric,... * `#7839 `__: sqrtm is unable to compute square root of zero matrix * `#7847 `__: solve is very slow since #6775 * `#7888 `__: Scipy 1.0.0b1 prints spurious DVODE/ZVODE/lsoda messages * `#7909 `__: bessel kv function in 0 is nan * `#7915 `__: LinearOperator's __init__ runs two times when instantiating the... * `#7958 `__: integrate.quad could use better error messages when given bad... * `#7968 `__: integrate.quad handles decreasing limits (b`__: ENH: matching return dtype for loggamma/gammaln * `#7991 `__: `lfilter` segfaults for integer inputs * `#8076 `__: "make dist" for the docs doesn't complete cleanly * `#8080 `__: Use JSON in `special/_generate_pyx.py`? * `#8127 `__: scipy.special.psi(x) very slow for some values of x * `#8145 `__: BUG: ndimage geometric_transform and zoom using deprecated NumPy... * `#8158 `__: BUG: romb print output requires correction * `#8181 `__: loadmat() raises TypeError instead of FileNotFound when reading... * `#8228 `__: bug for log1p on csr_matrix * `#8235 `__: scipy.stats multinomial pmf return nan * `#8271 `__: scipy.io.mmwrite raises type error for uint16 * `#8288 `__: Should tests be written for scipy.sparse.linalg.isolve.minres... * `#8298 `__: Broken links on scipy API web page * `#8329 `__: `_gels` fails for fat A matrix * `#8346 `__: Avoidable overflow in scipy.special.binom(n, k) * `#8371 `__: BUG: special: zetac(x) returns 0 for x < -30.8148 * `#8382 `__: collections.OrderedDict in test_mio.py * `#8492 `__: Missing documentation for `brute_force` parameter in scipy.ndimage.morphology * `#8532 `__: leastsq needlessly appends extra dimension for scalar problems * `#8544 `__: [feature request] Convert complex diagonal form to real block... * `#8561 `__: [Bug?] Example of Bland's Rule for optimize.linprog (simplex)... * `#8562 `__: CI: Appveyor builds fail because it can't import ConvexHull from... * `#8576 `__: BUG: optimize: `show_options(solver='minimize', method='Newton-CG')`... * `#8603 `__: test_roots_gegenbauer/chebyt/chebyc failures on manylinux * `#8604 `__: Test failures in scipy.sparse test_inplace_dense * `#8616 `__: special: ellpj.c code can be cleaned up a bit * `#8625 `__: scipy 1.0.1 no longer allows overwriting variables in netcdf... * `#8629 `__: gcrotmk.test_atol failure with MKL * `#8632 `__: Sigma clipping on data with the same value * `#8646 `__: scipy.special.sinpi test failures in test_zero_sign on old MSVC * `#8663 `__: linprog with method=interior-point produced incorrect answer... * `#8694 `__: linalg:TestSolve.test_all_type_size_routine_combinations fails... * `#8703 `__: Q: Does runtests.py --refguide-check need env (or other) variables... Pull requests for 1.1.0 - ----------------------- * `#6590 `__: BUG: sparse: fix custom rvs callable argument in sparse.random * `#7004 `__: ENH: scipy.linalg.eigsh cannot get all eigenvalues * `#7120 `__: ENH: implemented Owen's T function * `#7483 `__: ENH: Addition/multiplication operators for StateSpace systems * `#7566 `__: Informative exception when passing a sparse matrix * `#7592 `__: Adaptive Nelder-Mead * `#7729 `__: WIP: ENH: optimize: large-scale constrained optimization algorithms... * `#7802 `__: MRG: Add dpss window function * `#7803 `__: DOC: Add examples to spatial.distance * `#7821 `__: Add Returns section to the docstring * `#7833 `__: ENH: Performance improvements in scipy.linalg.special_matrices * `#7864 `__: MAINT: sparse: Simplify sputils.isintlike * `#7865 `__: ENH: Improved speed of copy into L, U matrices * `#7871 `__: ENH: sparse: Add 64-bit integer to sparsetools * `#7879 `__: ENH: re-enabled old sv lapack routine as defaults * `#7889 `__: DOC: Show probability density functions as math * `#7900 `__: API: Soft deprecate signal.* windows * `#7910 `__: ENH: allow `sqrtm` to compute the root of some singular matrices * `#7911 `__: MAINT: Avoid unnecessary array copies in xdist * `#7913 `__: DOC: Clarifies the meaning of `initial` of scipy.integrate.cumtrapz() * `#7916 `__: BUG: sparse.linalg: fix wrong use of __new__ in LinearOperator * `#7921 `__: BENCH: split spatial benchmark imports * `#7927 `__: ENH: added sygst/hegst routines to lapack * `#7934 `__: MAINT: add `io/_test_fortranmodule` to `.gitignore` * `#7936 `__: DOC: Fixed typo in scipy.special.roots_jacobi documentation * `#7937 `__: MAINT: special: Mark a test that fails on i686 as a known failure. * `#7941 `__: ENH: LDLt decomposition for indefinite symmetric/hermitian matrices * `#7945 `__: ENH: Implement reshape method on sparse matrices * `#7947 `__: DOC: update docs on releasing and installing/upgrading * `#7954 `__: Basin-hopping changes * `#7964 `__: BUG: test_falker not robust against numerical fuss in eigenvalues * `#7967 `__: QUADPACK Errors - human friendly errors to replace 'Invalid Input' * `#7975 `__: Make sure integrate.quad doesn't double-count singular points * `#7978 `__: TST: ensure negative weights are not allowed in distance metrics * `#7980 `__: MAINT: Truncate the warning msg about ill-conditioning * `#7981 `__: BUG: special: fix hyp2f1 behavior in certain circumstances * `#7983 `__: ENH: special: Add a real dispatch to `loggamma` * `#7989 `__: BUG: special: make `kv` return `inf` at a zero real argument * `#7990 `__: TST: special: test ufuncs in special at `nan` inputs * `#7994 `__: DOC: special: fix typo in spherical Bessel function documentation * `#7995 `__: ENH: linalg: add null_space for computing null spaces via svd * `#7999 `__: BUG: optimize: Protect _minpack calls with a lock. * `#8003 `__: MAINT: consolidate c99 compatibility * `#8004 `__: TST: special: get all `cython_special` tests running again * `#8006 `__: MAINT: Consolidate an additional _c99compat.h * `#8011 `__: Add new example of integrate.quad * `#8015 `__: DOC: special: remove `jn` from the refguide (again) * `#8018 `__: BUG - Issue with uint datatypes for array in get_index_dtype * `#8021 `__: DOC: spatial: Simplify Delaunay plotting * `#8024 `__: Documentation fix * `#8027 `__: BUG: io.matlab: fix saving unicode matrix names on py2 * `#8028 `__: BUG: special: some fixes for `lambertw` * `#8030 `__: MAINT: Bump Cython version * `#8034 `__: BUG: sparse.linalg: fix corner-case bug in expm * `#8035 `__: MAINT: special: remove complex division hack * `#8038 `__: ENH: Cythonize pyx files if pxd dependencies change * `#8042 `__: TST: stats: reduce required precision in test_fligner * `#8043 `__: TST: Use diff. values for decimal keyword for single and doubles * `#8044 `__: TST: accuracy of tests made different for singles and doubles * `#8049 `__: Unhelpful error message when calling scipy.sparse.save_npz on... * `#8052 `__: TST: spatial: add a regression test for gh-8051 * `#8059 `__: BUG: special: fix ufunc results for `nan` arguments * `#8066 `__: MAINT: special: reimplement inverses of incomplete gamma functions * `#8072 `__: Example for scipy.fftpack.ifft, https://github.com/scipy/scipy/issues/7168 * `#8073 `__: Example for ifftn, https://github.com/scipy/scipy/issues/7168 * `#8078 `__: Link to CoC in contributing.rst doc * `#8085 `__: BLD: Fix npy_isnan of integer variables in cephes * `#8088 `__: DOC: note version for which new attributes have been added to... * `#8090 `__: BUG: special: add nan check to `_legacy_cast_check` functions * `#8091 `__: Doxy Typos + trivial comment typos (2nd attempt) * `#8096 `__: TST: special: simplify `Arg` * `#8101 `__: MAINT: special: run `_generate_pyx.py` when `add_newdocs.py`... * `#8104 `__: Input checking for scipy.sparse.linalg.inverse() * `#8105 `__: DOC: special: Update the 'euler' docstring. * `#8109 `__: MAINT: fixing code comments and hyp2f1 docstring: see issues... * `#8112 `__: More trivial typos * `#8113 `__: MAINT: special: generate test data npz files in setup.py and... * `#8116 `__: DOC: add build instructions * `#8120 `__: DOC: Clean up README * `#8121 `__: DOC: Add missing colons in docstrings * `#8123 `__: BLD: update Bento build config files for recent C99 changes. * `#8124 `__: Change to avoid use of `fmod` in scipy.signal.chebwin * `#8126 `__: Added examples for mode arg in geometric_transform * `#8128 `__: relax relative tolerance parameter in TestMinumumPhase.test_hilbert * `#8129 `__: ENH: special: use rational approximation for `digamma` on `[1,... * `#8137 `__: DOC Correct matrix width * `#8141 `__: MAINT: optimize: remove unused `__main__` code in L-BSGS-B * `#8147 `__: BLD: update Bento build for removal of .npz scipy.special test... * `#8148 `__: Alias hanning as an explanatory function of hann * `#8149 `__: MAINT: special: small fixes for `digamma` * `#8159 `__: Update version classifiers * `#8164 `__: BUG: riccati solvers don't catch ill-conditioned problems sufficiently... * `#8168 `__: DOC: release note for sparse resize methods * `#8170 `__: BUG: correctly pad netCDF files with null bytes * `#8171 `__: ENH added normal inverse gaussian distribution to scipy.stats * `#8175 `__: DOC: Add example to scipy.ndimage.zoom * `#8177 `__: MAINT: diffev small speedup in ensure constraint * `#8178 `__: FIX: linalg._qz String formatter syntax error * `#8179 `__: TST: Added pdist to asv spatial benchmark suite * `#8180 `__: TST: ensure constraint test improved * `#8183 `__: 0d conj correlate * `#8186 `__: BUG: special: fix derivative of `spherical_jn(1, 0)` * `#8194 `__: Fix warning message * `#8196 `__: BUG: correctly handle inputs with nan's and ties in spearmanr * `#8198 `__: MAINT: stats.triang edge case fixes #6036 * `#8200 `__: DOC: Completed "Examples" sections of all linalg funcs * `#8201 `__: MAINT: stats.trapz edge cases * `#8204 `__: ENH: sparse.linalg/lobpcg: change .T to .T.conj() to support... * `#8206 `__: MAINT: missed triang edge case. * `#8214 `__: BUG: Fix memory corruption in linalg._decomp_update C extension * `#8222 `__: DOC: recommend scipy.integrate.solve_ivp * `#8223 `__: ENH: added Moyal distribution to scipy.stats * `#8232 `__: BUG: sparse: Use deduped data for numpy ufuncs * `#8236 `__: Fix #8235 * `#8253 `__: BUG: optimize: fix bug related with function call calculation... * `#8264 `__: ENH: Extend peak finding capabilities in scipy.signal * `#8273 `__: BUG fixed printing of convergence message in minimize_scalar... * `#8276 `__: DOC: Add notes to explain constrains on overwrite_<> * `#8279 `__: CI: fixing doctests * `#8282 `__: MAINT: weightedtau, change search for nan * `#8287 `__: Improving documentation of solve_ivp and the underlying solvers * `#8291 `__: DOC: fix non-ascii characters in docstrings which broke the doc... * `#8292 `__: CI: use numpy 1.13 for refguide check build * `#8296 `__: Fixed bug reported in issue #8181 * `#8297 `__: DOC: Examples for linalg/decomp eigvals function * `#8300 `__: MAINT: Housekeeping for minimizing the linalg compiler warnings * `#8301 `__: DOC: make public API documentation cross-link to refguide. * `#8302 `__: make sure _onenorm_matrix_power_nnm actually returns a float * `#8313 `__: Change copyright to outdated 2008-2016 to 2008-year * `#8315 `__: TST: Add tests for `scipy.sparse.linalg.isolve.minres` * `#8318 `__: ENH: odeint: Add the argument 'tfirst' to odeint. * `#8328 `__: ENH: optimize: ``trust-constr`` optimization algorithms [GSoC... * `#8330 `__: ENH: add a maxiter argument to NNLS * `#8331 `__: DOC: tweak the Moyal distribution docstring * `#8333 `__: FIX: Rewrapped ?gels and ?gels_lwork routines * `#8336 `__: MAINT: integrate: handle b < a in quad * `#8337 `__: BUG: special: Ensure zetac(1) returns inf. * `#8347 `__: BUG: Fix overflow in special.binom. Issue #8346 * `#8356 `__: DOC: Corrected Documentation Issue #7750 winsorize function * `#8358 `__: ENH: stats: Use explicit MLE formulas in lognorm.fit and expon.fit * `#8374 `__: BUG: gh7854, maxiter for l-bfgs-b closes #7854 * `#8379 `__: CI: enable gcov coverage on travis * `#8383 `__: Removed collections.OrderedDict import ignore. * `#8384 `__: TravisCI: tool pep8 is now pycodestyle * `#8387 `__: MAINT: special: remove unused specfun code for Struve functions * `#8393 `__: DOC: Replace old type names in ndimage tutorial. * `#8400 `__: Fix tolerance specification in sparse.linalg iterative solvers * `#8402 `__: MAINT: Some small cleanups in ndimage. * `#8403 `__: FIX: Make scipy.optimize.zeros run under PyPy * `#8407 `__: BUG: sparse.linalg: fix termination bugs for cg, cgs * `#8409 `__: MAINT: special: add a `.pxd` file for Cephes functions * `#8412 `__: MAINT: special: remove `cephes/protos.h` * `#8421 `__: Setting "unknown" message in OptimizeResult when calling MINPACK. * `#8423 `__: FIX: Handle unsigned integers in mmio * `#8426 `__: DOC: correct FAQ entry on Apache license compatibility. Closes... * `#8433 `__: MAINT: add `.pytest_cache` to the `.gitignore` * `#8436 `__: MAINT: scipy.sparse: less copies at transpose method * `#8437 `__: BUG: correct behavior for skew-symmetric matrices in io.mmwrite * `#8440 `__: DOC:Add examples to integrate.quadpack docstrings * `#8441 `__: BUG: sparse.linalg/gmres: deal with exact breakdown in gmres * `#8442 `__: MAINT: special: clean up Cephes header files * `#8448 `__: TST: Generalize doctest stopwords .axis( .plot( * `#8457 `__: MAINT: special: use JSON for function signatures in `_generate_pyx.py` * `#8461 `__: MAINT: Simplify return value of ndimage functions. * `#8464 `__: MAINT: Trivial typos * `#8474 `__: BUG: spatial: make qhull.pyx more pypy-friendly * `#8476 `__: TST: _lib: disable refcounting tests on PyPy * `#8479 `__: BUG: io/matlab: fix issues in matlab i/o on pypy * `#8481 `__: DOC: Example for signal.cmplx_sort * `#8482 `__: TST: integrate: use integers instead of PyCapsules to store pointers * `#8483 `__: ENH: io/netcdf: make mmap=False the default on PyPy * `#8484 `__: BUG: io/matlab: work around issue in to_writeable on PyPy * `#8488 `__: MAINT: special: add const/static specifiers where possible * `#8489 `__: BUG: ENH: use common halley's method instead of parabolic variant * `#8491 `__: DOC: fix typos * `#8496 `__: ENH: special: make Chebyshev nodes symmetric * `#8501 `__: BUG: stats: Split the integral used to compute skewnorm.cdf. * `#8502 `__: WIP: Port CircleCI to v2 * `#8507 `__: DOC: Add missing description to `brute_force` parameter. * `#8509 `__: BENCH: forgot to add nelder-mead to list of methods * `#8512 `__: MAINT: Move spline interpolation code to spline.c * `#8513 `__: TST: special: mark a slow test as xslow * `#8514 `__: CircleCI: Share data between jobs * `#8515 `__: ENH: special: improve accuracy of `zetac` for negative arguments * `#8520 `__: TST: Decrease the array sizes for two linalg tests * `#8522 `__: TST: special: restrict range of `test_besselk`/`test_besselk_int` * `#8527 `__: Documentation - example added for voronoi_plot_2d * `#8528 `__: DOC: Better, shared docstrings in ndimage * `#8533 `__: BUG: Fix PEP8 errors introduced in #8528. * `#8534 `__: ENH: Expose additional window functions * `#8538 `__: MAINT: Fix a couple mistakes in .pyf files. * `#8540 `__: ENH: interpolate: allow string aliases in make_interp_spline... * `#8541 `__: ENH: Cythonize peak_prominences * `#8542 `__: Remove numerical arguments from convolve2d / correlate2d * `#8546 `__: ENH: New arguments, documentation, and tests for ndimage.binary_opening * `#8547 `__: Giving both size and input now raises UserWarning (#7334) * `#8549 `__: DOC: stats: invweibull is also known as Frechet or type II extreme... * `#8550 `__: add cdf2rdf function * `#8551 `__: ENH: Port of most of the dd_real part of the qd high-precision... * `#8553 `__: Note in docs to address issue #3164. * `#8554 `__: ENH: stats: Use explicit MLE formulas in uniform.fit() * `#8555 `__: MAINT: adjust benchmark config * `#8557 `__: [DOC]: fix Nakagami density docstring * `#8559 `__: DOC: Fix docstring of diric(x, n) * `#8563 `__: [DOC]: fix gamma density docstring * `#8564 `__: BLD: change default Python version for doc build from 2.7 to... * `#8568 `__: BUG: Fixes Bland's Rule for pivot row/leaving variable, closes... * `#8572 `__: ENH: Add previous/next to interp1d * `#8578 `__: Example for linalg.eig() * `#8580 `__: DOC: update link to asv docs * `#8584 `__: filter_design: switch to explicit arguments, keeping None as... * `#8586 `__: DOC: stats: Add parentheses that were missing in the exponnorm... * `#8587 `__: TST: add benchmark for newton, secant, halley * `#8588 `__: DOC: special: Remove heaviside from "functions not in special"... * `#8591 `__: DOC: cdf2rdf Added version info and "See also" * `#8594 `__: ENH: Cythonize peak_widths * `#8595 `__: MAINT/ENH/BUG/TST: cdf2rdf: Address review comments made after... * `#8597 `__: DOC: add versionadded 1.1.0 for new keywords in ndimage.morphology * `#8605 `__: MAINT: special: improve implementations of `sinpi` and `cospi` * `#8607 `__: MAINT: add 2D benchmarks for convolve * `#8608 `__: FIX: Fix int check * `#8613 `__: fix typo in doc of signal.peak_widths * `#8615 `__: TST: fix failing linalg.qz float32 test by decreasing precision. * `#8617 `__: MAINT: clean up code in ellpj.c * `#8618 `__: add fsolve docs it doesn't handle over- or under-determined problems * `#8620 `__: DOC: add note on dtype attribute of aslinearoperator() argument * `#8627 `__: ENH: Add example 1D signal (ECG) to scipy.misc * `#8630 `__: ENH: Remove unnecessary copying in stats.percentileofscore * `#8631 `__: BLD: fix pdf doc build. closes gh-8076 * `#8633 `__: BUG: fix regression in `io.netcdf_file` with append mode. * `#8635 `__: MAINT: remove spurious warning from (z)vode and lsoda. Closes... * `#8636 `__: BUG: sparse.linalg/gcrotmk: avoid rounding error in termination... * `#8637 `__: For pdf build * `#8639 `__: CI: build pdf documentation on circleci * `#8640 `__: TST: fix special test that was importing `np.testing.utils` (deprecated) * `#8641 `__: BUG: optimize: fixed sparse redundancy removal bug * `#8645 `__: BUG: modified sigmaclip to avoid clipping of constant input in... * `#8647 `__: TST: sparse: skip test_inplace_dense for numpy<1.13 * `#8657 `__: Latex reduce left margins * `#8659 `__: TST: special: skip sign-of-zero test on 32-bit win32 with old... * `#8661 `__: Fix dblquad and tplquad not accepting float boundaries * `#8666 `__: DOC: fixes #8532 * `#8667 `__: BUG: optimize: fixed issue #8663 * `#8668 `__: Fix example in docstring of netcdf_file * `#8671 `__: DOC: Replace deprecated matplotlib kwarg * `#8673 `__: BUG: special: Use a stricter tolerance for the chndtr calculation. * `#8674 `__: ENH: In the Dirichlet distribution allow x_i to be 0 if alpha_i... * `#8676 `__: BUG: optimize: partial fix to linprog fails to detect infeasibility... * `#8685 `__: DOC: Add interp1d-next/previous example to tutorial * `#8687 `__: TST: netcdf: explicit mmap=True in test * `#8688 `__: BUG: signal, stats: use Python sum() instead of np.sum for summing... * `#8689 `__: TST: bump tolerances in tests * `#8690 `__: DEP: deprecate stats.itemfreq * `#8691 `__: BLD: special: fix build vs. dd_real.h package * `#8695 `__: DOC: Improve examples in signal.find_peaks with ECG signal * `#8697 `__: BUG: Fix `setup.py build install egg_info`, which did not previously... * `#8704 `__: TST: linalg: drop large size from solve() test * `#8705 `__: DOC: Describe signal.find_peaks and related functions behavior... * `#8706 `__: DOC: Specify encoding of rst file, remove an ambiguity in an... * `#8710 `__: MAINT: fix an import cycle sparse -> special -> integrate ->... * `#8711 `__: ENH: remove an avoidable overflow in scipy.stats.norminvgauss.pdf() * `#8716 `__: BUG: interpolate: allow list inputs for make_interp_spline(...,... * `#8720 `__: np.testing import that is compatible with numpy 1.15 * `#8724 `__: CI: don't use pyproject.toml in the CI builds Checksums ========= MD5 ~~~ 5f5dac4aeb117e977eba6b57231f467a scipy-1.1.0-cp27-cp27m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl 8f47f7779047f19ab0b54821bfbf699e scipy-1.1.0-cp27-cp27m-manylinux1_i686.whl 4cd3a7840cccb7bd8001cca94cd5264d scipy-1.1.0-cp27-cp27m-manylinux1_x86_64.whl 5a6981b403117237066a289df8a3e41e scipy-1.1.0-cp27-cp27mu-manylinux1_i686.whl 1370771ae0d6032c415cd1ff74be0308 scipy-1.1.0-cp27-cp27mu-manylinux1_x86_64.whl 6fd9d352028851983efadcd7cc93486a scipy-1.1.0-cp27-none-win32.whl af1a53b10b754bb73afbce2d4333e25a scipy-1.1.0-cp27-none-win_amd64.whl 28a40c0cc6516faa85c2d6a4b759d49b scipy-1.1.0-cp34-cp34m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl fe52c136fd85780e1b8eae61f547573f scipy-1.1.0-cp34-cp34m-manylinux1_i686.whl 0beed5f35d90e47ca0a19df1b4d6705b scipy-1.1.0-cp34-cp34m-manylinux1_x86_64.whl 149d429369a8d4c65340da5f4d7f3c5c scipy-1.1.0-cp34-none-win32.whl f53881e219fe7b1e7baafc16076b8037 scipy-1.1.0-cp34-none-win_amd64.whl 02c5f91e021aff8e0616ddb3e13b2939 scipy-1.1.0-cp35-cp35m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl 85abc7a569fb1a0eb83e889c2dbf9415 scipy-1.1.0-cp35-cp35m-manylinux1_i686.whl 959d873bda4753d33b4f2f4e882027d7 scipy-1.1.0-cp35-cp35m-manylinux1_x86_64.whl 53aa31c367ae288d9268ab80fcabae98 scipy-1.1.0-cp35-none-win32.whl 5231103cf8f60d377395992c64dca3e8 scipy-1.1.0-cp35-none-win_amd64.whl 911883861aaa4030f49290134057cd14 scipy-1.1.0-cp36-cp36m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl c20dd7bd0ee52dda5d9f364ed30868e0 scipy-1.1.0-cp36-cp36m-manylinux1_i686.whl 6ceb8c9e15464bc097d6fb033df36436 scipy-1.1.0-cp36-cp36m-manylinux1_x86_64.whl a47007af1f8fa31abffddca45aa8dba6 scipy-1.1.0-cp36-none-win32.whl 748e458b4a488894007afdc5740dca12 scipy-1.1.0-cp36-none-win_amd64.whl aa6bcc85276b6f25e17bcfc4dede8718 scipy-1.1.0.tar.gz 7ff4ecfd9f0e953c2ec36c934ee65a97 scipy-1.1.0.tar.xz 6b56add6c5994ebf6d0c2861c538a86c scipy-1.1.0.zip SHA256 ~~~~~~ 340ef70f5b0f4e2b4b43c8c8061165911bc6b2ad16f8de85d9774545e2c47463 scipy-1.1.0-cp27-cp27m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl c22b27371b3866c92796e5d7907e914f0e58a36d3222c5d436ddd3f0e354227a scipy-1.1.0-cp27-cp27m-manylinux1_i686.whl d8491d4784aceb1f100ddb8e31239c54e4afab8d607928a9f7ef2469ec35ae01 scipy-1.1.0-cp27-cp27m-manylinux1_x86_64.whl 8190770146a4c8ed5d330d5b5ad1c76251c63349d25c96b3094875b930c44692 scipy-1.1.0-cp27-cp27mu-manylinux1_i686.whl 08237eda23fd8e4e54838258b124f1cd141379a5f281b0a234ca99b38918c07a scipy-1.1.0-cp27-cp27mu-manylinux1_x86_64.whl dfc5080c38dde3f43d8fbb9c0539a7839683475226cf83e4b24363b227dfe552 scipy-1.1.0-cp27-none-win32.whl e7a01e53163818d56eabddcafdc2090e9daba178aad05516b20c6591c4811020 scipy-1.1.0-cp27-none-win_amd64.whl 0e645dbfc03f279e1946cf07c9c754c2a1859cb4a41c5f70b25f6b3a586b6dbd scipy-1.1.0-cp34-cp34m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl f0521af1b722265d824d6ad055acfe9bd3341765735c44b5a4d0069e189a0f40 scipy-1.1.0-cp34-cp34m-manylinux1_i686.whl 3b243c77a822cd034dad53058d7c2abf80062aa6f4a32e9799c95d6391558631 scipy-1.1.0-cp34-cp34m-manylinux1_x86_64.whl 8f841bbc21d3dad2111a94c490fb0a591b8612ffea86b8e5571746ae76a3deac scipy-1.1.0-cp34-none-win32.whl ee677635393414930541a096fc8e61634304bb0153e4e02b75685b11eba14cae scipy-1.1.0-cp34-none-win_amd64.whl 423b3ff76957d29d1cce1bc0d62ebaf9a3fdfaf62344e3fdec14619bb7b5ad3a scipy-1.1.0-cp35-cp35m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl 0611ee97296265af4a21164a5323f8c1b4e8e15c582d3dfa7610825900136bb7 scipy-1.1.0-cp35-cp35m-manylinux1_i686.whl 108c16640849e5827e7d51023efb3bd79244098c3f21e4897a1007720cb7ce37 scipy-1.1.0-cp35-cp35m-manylinux1_x86_64.whl 3ad73dfc6f82e494195144bd3a129c7241e761179b7cb5c07b9a0ede99c686f3 scipy-1.1.0-cp35-none-win32.whl d0cdd5658b49a722783b8b4f61a6f1f9c75042d0e29a30ccb6cacc9b25f6d9e2 scipy-1.1.0-cp35-none-win_amd64.whl e24e22c8d98d3c704bb3410bce9b69e122a8de487ad3dbfe9985d154e5c03a40 scipy-1.1.0-cp36-cp36m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl 404a00314e85eca9d46b80929571b938e97a143b4f2ddc2b2b3c91a4c4ead9c5 scipy-1.1.0-cp36-cp36m-manylinux1_i686.whl 729f8f8363d32cebcb946de278324ab43d28096f36593be6281ca1ee86ce6559 scipy-1.1.0-cp36-cp36m-manylinux1_x86_64.whl 0e9bb7efe5f051ea7212555b290e784b82f21ffd0f655405ac4f87e288b730b3 scipy-1.1.0-cp36-none-win32.whl 698c6409da58686f2df3d6f815491fd5b4c2de6817a45379517c92366eea208f scipy-1.1.0-cp36-none-win_amd64.whl 878352408424dffaa695ffedf2f9f92844e116686923ed9aa8626fc30d32cfd1 scipy-1.1.0.tar.gz a18cc84d1c784c78b06f0f2adc400b29647728712f3843fc890c02aad1ac5424 scipy-1.1.0.tar.xz 391af739bf65c3915f229647d858c15fca0b96dac0497901a4fe2bd3fa69f40b scipy-1.1.0.zip -----BEGIN PGP SIGNATURE----- iQIzBAEBCAAdFiEEiNDtwDFNJaodBiJZHOiglY3YpVcFAlrt+ZMACgkQHOiglY3Y pVcnNBAAk+tuy6qyPZJomc7urrz804VZdDH81hLfEHww7g5DpIYGk54rkyKgeDWT /ZveYcSzUc+zm81qmDZPb6ctfB7MH2B2mXUfNvxZkGYDseYIJyLtO10/hrqxyHsL YXGp4nD4QEeJ696OYyuaYxnjVe64dz2Lc25l6MBPdcevH9bY2MG2q95ajZKX3k2y QUM5OsBZzKfGWCaXCYFt6E+FcEQ9cLfTBUQNxktCrDosuPBv+jy8ukwDj5NSqBwg zM4lZ3C/lXF4v68cye17voJqr5fIEA+Y61jK200TwJO+jH9ifUs9hR5ED1PLzvMK SRIxX+5digAe0iAVHkOeGS9fTEFTSoT62fqYMIVdSRv6zId9FcGiP54h94676wB8 OYApvcxLQqaGnsMW462EQsKg/oXd+MXcwX4Gpn1WQT8XDmlygsLyIPduymNKeh6/ L53UJsjLgC4ize7oM7ppfAPo+OmxAqzuUxd2K57Jr+hWUThmWmE+3BkAipH/XP+4 w3cApggI1KCooi9Kt/IkYxUPjwdAwuQjuKB/PpPpfRdnCwveXasJS/hcld3f4y5j GBQ8QT2wT4P9wS20b5yfuy5FpL7Ss9eTbKihXzjT7ymxz2IY6gl47m+Aug8laexn kE/l/XmWUU2D+/VdZAgHFenigI/z6iv/EhiPeZR+GEkYIl/a+QM= =OnQY -----END PGP SIGNATURE----- From pierre.debuyl at kuleuven.be Wed May 9 17:51:09 2018 From: pierre.debuyl at kuleuven.be (Pierre de Buyl) Date: Wed, 9 May 2018 23:51:09 +0200 Subject: [SciPy-User] EuroSciPy 2018 - call for abstracts Message-ID: <20180509215109.GH2378@pi-x230> EuroSciPy 2018 https://www.euroscipy.org/2018/ has opened its call for abstracts for talks, posters, and tutorials! It was announced via twitter and our "announcement" mailing list but I did not reach out to the NumPy/SciPy lists yet, so I'll just mention: 1. The conference is in Trento (IT), 28 Aug. - 1 Sep. 2. The deadline for the call is the 13 May 3. Tutorials are included in the call, if you wish to have an idea of what we are looking for, see https://scipy2017.scipy.org/ehome/220975/493418/ (SciPy US 2017) or https://www.euroscipy.org/2017/program.html (EuroSciPy 2017). Regards, Pierre de Buyl From pierre.debuyl at kuleuven.be Thu May 17 11:30:21 2018 From: pierre.debuyl at kuleuven.be (Pierre de Buyl) Date: Thu, 17 May 2018 17:30:21 +0200 Subject: [SciPy-User] EuroSciPy 2018 - extended deadline - registration open Message-ID: <20180517153021.GI11858@pi-x230> Dear SciPy community, The EuroSciPy 2018 conference, held in Trento from August 28 to September 1 has opened its registration at https://www.euroscipy.org/2018/ ! Also, the deadline for participations (talks, posters, tutorials) has been extended to May 31, don't miss it! All the info is on our web page, feel free to contact us if needed and follow us on Twitter :-) https://twitter.com/EuroSciPy Regards, The EuroSciPy staff From winash12 at gmail.com Sun May 20 12:09:45 2018 From: winash12 at gmail.com (ashwin .D) Date: Sun, 20 May 2018 21:39:45 +0530 Subject: [SciPy-User] KD Tree with great circle distances Message-ID: Hello, I am using - https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree which I believe is using Euclidean distances underneath the hood. But I want to be able to use great circle distances. Is this the only way to do this - https://stackoverflow.com/questions/20654918/python-how-to-speed-up-calculation-of-distances-between-cities or is there some way I can extend that class to use great circle distances(maybe somebody has already done that ? ) I have a irregular shaped grid in a WGS 84 ellipsoid(can be assumed to be a sphere) and so I want to use great circle distances or if somebody can convince me not to that would be great as well. Best regards, Ashwin. -------------- next part -------------- An HTML attachment was scrubbed... URL: From dhoese at gmail.com Sun May 20 12:26:52 2018 From: dhoese at gmail.com (David Hoese) Date: Sun, 20 May 2018 11:26:52 -0500 Subject: [SciPy-User] KD Tree with great circle distances In-Reply-To: References: Message-ID: <9f507da2-dd90-fc8c-d9ee-fa3b5e1e0c8e@gmail.com> Hi Ashwin, As far as I know this is the easiest way to do it. I'm not a scipy developer, but you may be interested in the pyresample package: http://pyresample.readthedocs.io/en/latest/ Which uses the pykdtree library: https://github.com/storpipfugl/pykdtree And can perform resampling of irregularly spaced data. For certain calculations/utilities it will also convert to XYZ space as described in that SO answer. Hope this helps a little, sorry if it isn't the answer you're looking for. Dave On 5/20/18 11:09 AM, ashwin .D wrote: > Hello, > ?????????? I am using - > https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree > which? I believe is using Euclidean distances underneath the hood. But I > want to be able to use great circle distances. Is this the only way to > do this - > https://stackoverflow.com/questions/20654918/python-how-to-speed-up-calculation-of-distances-between-cities > or is there some way I can extend that class to use great circle > distances(maybe somebody has already done that ? ) I have a irregular > shaped grid in a WGS 84 ellipsoid(can be assumed to be a sphere) and so > I want to use great circle distances or if somebody can convince me not > to that would be great as well. > > > Best regards, > Ashwin. > > > _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > From winash12 at gmail.com Sun May 20 12:49:00 2018 From: winash12 at gmail.com (ashwin .D) Date: Sun, 20 May 2018 22:19:00 +0530 Subject: [SciPy-User] KD Tree with great circle distances In-Reply-To: <9f507da2-dd90-fc8c-d9ee-fa3b5e1e0c8e@gmail.com> References: <9f507da2-dd90-fc8c-d9ee-fa3b5e1e0c8e@gmail.com> Message-ID: Hi David, Many thanks for your prompt response and that maybe the route that I may have to take eventually. I was just wondering whether scipy has any equivalent for the stuff described in this paper - http://www.soest.hawaii.edu/wessel/sphspline/Wessel+Becker_2008_GJI.pdf ? Regards, Ashwin. On Sun, May 20, 2018 at 9:56 PM, David Hoese wrote: > Hi Ashwin, > > As far as I know this is the easiest way to do it. I'm not a scipy > developer, but you may be interested in the pyresample package: > > http://pyresample.readthedocs.io/en/latest/ > > Which uses the pykdtree library: > > https://github.com/storpipfugl/pykdtree > > And can perform resampling of irregularly spaced data. For certain > calculations/utilities it will also convert to XYZ space as described in > that SO answer. Hope this helps a little, sorry if it isn't the answer > you're looking for. > > Dave > > > On 5/20/18 11:09 AM, ashwin .D wrote: > >> Hello, >> I am using - https://docs.scipy.org/doc/sci >> py/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree >> which I believe is using Euclidean distances underneath the hood. But I >> want to be able to use great circle distances. Is this the only way to do >> this - https://stackoverflow.com/questions/20654918/python-how-to- >> speed-up-calculation-of-distances-between-cities or is there some way I >> can extend that class to use great circle distances(maybe somebody has >> already done that ? ) I have a irregular shaped grid in a WGS 84 >> ellipsoid(can be assumed to be a sphere) and so I want to use great circle >> distances or if somebody can convince me not to that would be great as well. >> >> >> Best regards, >> Ashwin. >> >> >> _______________________________________________ >> SciPy-User mailing list >> SciPy-User at python.org >> https://mail.python.org/mailman/listinfo/scipy-user >> >> _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > -------------- next part -------------- An HTML attachment was scrubbed... URL: From edward.grys at gmail.com Sun May 20 15:57:12 2018 From: edward.grys at gmail.com (Edward Gryspeerdt) Date: Sun, 20 May 2018 20:57:12 +0100 Subject: [SciPy-User] KD Tree with great circle distances In-Reply-To: References: <9f507da2-dd90-fc8c-d9ee-fa3b5e1e0c8e@gmail.com> Message-ID: Hi Ashwin, If you are using the whole globe, you might want to consider using something like a VP-tree instead. A KD-tree needs left/right to be defined, which you can't do on a sphere. Scikit-learn has a BallTree, which you can use with a 'haversine' distance metric, which should allow you to do do nearest neighbours on a sphere http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html Hope that helps, Ed On 20 May 2018 at 17:49, ashwin .D wrote: > Hi David, > Many thanks for your prompt response and that maybe the > route that I may have to take eventually. I was just wondering whether > scipy has any equivalent for the stuff described in this paper - > http://www.soest.hawaii.edu/wessel/sphspline/Wessel+Becker_2008_GJI.pdf ? > > Regards, > Ashwin. > > On Sun, May 20, 2018 at 9:56 PM, David Hoese wrote: > >> Hi Ashwin, >> >> As far as I know this is the easiest way to do it. I'm not a scipy >> developer, but you may be interested in the pyresample package: >> >> http://pyresample.readthedocs.io/en/latest/ >> >> Which uses the pykdtree library: >> >> https://github.com/storpipfugl/pykdtree >> >> And can perform resampling of irregularly spaced data. For certain >> calculations/utilities it will also convert to XYZ space as described in >> that SO answer. Hope this helps a little, sorry if it isn't the answer >> you're looking for. >> >> Dave >> >> >> On 5/20/18 11:09 AM, ashwin .D wrote: >> >>> Hello, >>> I am using - https://docs.scipy.org/doc/sci >>> py/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree >>> which I believe is using Euclidean distances underneath the hood. But I >>> want to be able to use great circle distances. Is this the only way to do >>> this - https://stackoverflow.com/questions/20654918/python-how-to-s >>> peed-up-calculation-of-distances-between-cities or is there some way I >>> can extend that class to use great circle distances(maybe somebody has >>> already done that ? ) I have a irregular shaped grid in a WGS 84 >>> ellipsoid(can be assumed to be a sphere) and so I want to use great circle >>> distances or if somebody can convince me not to that would be great as well. >>> >>> >>> Best regards, >>> Ashwin. >>> >>> >>> _______________________________________________ >>> SciPy-User mailing list >>> SciPy-User at python.org >>> https://mail.python.org/mailman/listinfo/scipy-user >>> >>> _______________________________________________ >> SciPy-User mailing list >> SciPy-User at python.org >> https://mail.python.org/mailman/listinfo/scipy-user >> > > > _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > > -- Public key available at pgp.mit.edu , ID:B30279BC -------------- next part -------------- An HTML attachment was scrubbed... URL: From charlesr.harris at gmail.com Sun May 20 17:35:57 2018 From: charlesr.harris at gmail.com (Charles R Harris) Date: Sun, 20 May 2018 15:35:57 -0600 Subject: [SciPy-User] KD Tree with great circle distances In-Reply-To: References: <9f507da2-dd90-fc8c-d9ee-fa3b5e1e0c8e@gmail.com> Message-ID: On Sun, May 20, 2018 at 1:57 PM, Edward Gryspeerdt wrote: > Hi Ashwin, > > If you are using the whole globe, you might want to consider using > something like a VP-tree instead. A KD-tree needs left/right to be > defined, which you can't do on a sphere. > > Scikit-learn has a BallTree, which you can use with a 'haversine' distance > metric, which should allow you to do do nearest neighbours on a sphere > > http://scikit-learn.org/stable/modules/generated/ > sklearn.neighbors.BallTree.html > > Hope that helps, > Ed > > > On 20 May 2018 at 17:49, ashwin .D wrote: > >> Hi David, >> Many thanks for your prompt response and that maybe the >> route that I may have to take eventually. I was just wondering whether >> scipy has any equivalent for the stuff described in this paper - >> http://www.soest.hawaii.edu/wessel/sphspline/Wessel+Becker_2008_GJI.pdf ? >> >> Regards, >> Ashwin. >> >> On Sun, May 20, 2018 at 9:56 PM, David Hoese wrote: >> >>> Hi Ashwin, >>> >>> As far as I know this is the easiest way to do it. I'm not a scipy >>> developer, but you may be interested in the pyresample package: >>> >>> http://pyresample.readthedocs.io/en/latest/ >>> >>> Which uses the pykdtree library: >>> >>> https://github.com/storpipfugl/pykdtree >>> >>> And can perform resampling of irregularly spaced data. For certain >>> calculations/utilities it will also convert to XYZ space as described in >>> that SO answer. Hope this helps a little, sorry if it isn't the answer >>> you're looking for. >>> >>> Dave >>> >>> >>> On 5/20/18 11:09 AM, ashwin .D wrote: >>> >>>> Hello, >>>> I am using - https://docs.scipy.org/doc/sci >>>> py/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree >>>> which I believe is using Euclidean distances underneath the hood. But I >>>> want to be able to use great circle distances. Is this the only way to do >>>> this - https://stackoverflow.com/questions/20654918/python-how-to-s >>>> peed-up-calculation-of-distances-between-cities or is there some way I >>>> can extend that class to use great circle distances(maybe somebody has >>>> already done that ? ) I have a irregular shaped grid in a WGS 84 >>>> ellipsoid(can be assumed to be a sphere) and so I want to use great circle >>>> distances or if somebody can convince me not to that would be great as well. >>>> >>>> >>>> Best regards, >>>> Ashwin. >>>> >>>> >>>> _______________________________________________ >>>> SciPy-User mailing list >>>> SciPy-User at python.org >>>> https://mail.python.org/mailman/listinfo/scipy-user >>>> >>>> _______________________________________________ >>> SciPy-User mailing list >>> SciPy-User at python.org >>> https://mail.python.org/mailman/listinfo/scipy-user >>> >> >> >> _______________________________________________ >> SciPy-User mailing list >> SciPy-User at python.org >> https://mail.python.org/mailman/listinfo/scipy-user >> >> > If the points are on the surface of the globe and the deviation of the ideal surface from a sphere can be neglected, then the mapping from 3-D distance to great circle distance is 1-1 and well defined. Not sure how inefficient 3-D indexing of points on the surface would be, but suspect it isn't too bad. Much depends on the specifics of the problem, and the amount of data. If nothing else, selected points could be checked for spherical distance. I've also mapped spheres onto an octahedron and indexed the sides, but that may not be useful for what you want to do. I suppose you could also use a tetrahedron, which is self dual and would allow two similar indexes and avoid edges and vertices if you were only looking for nearby points. Chuck -------------- next part -------------- An HTML attachment was scrubbed... URL: From winash12 at gmail.com Sun May 20 21:35:21 2018 From: winash12 at gmail.com (ashwin .D) Date: Mon, 21 May 2018 07:05:21 +0530 Subject: [SciPy-User] KD Tree with great circle distances In-Reply-To: References: <9f507da2-dd90-fc8c-d9ee-fa3b5e1e0c8e@gmail.com> Message-ID: Hi Ed, I believe it is indeed very helpful and I may end up using either the VP tree or the Ball tree. In order to give you few more details I have data on a WGS 84 ellipsoid(we can assume this to be a sphere) from 66 N to 66 S and all the longitudes. The data is three dimensional but is equidistant along the third dimension i.e. height. The data is also highly sparse. From a flattened version of the 3d array I have 22163680 points and out of that only 266111 points have finite values(greater than zero). The rest are all NaNs.But the finite data(those values that are greater than zero) is clustered i.e. possibly very close to each other. The resolution horizontally is around 5 kms. What I intend to do is to 2D interpolation for each height level. Best regards, Ashwin. On Mon, May 21, 2018 at 1:27 AM, Edward Gryspeerdt wrote: > Hi Ashwin, > > If you are using the whole globe, you might want to consider using > something like a VP-tree instead. A KD-tree needs left/right to be > defined, which you can't do on a sphere. > > Scikit-learn has a BallTree, which you can use with a 'haversine' distance > metric, which should allow you to do do nearest neighbours on a sphere > > http://scikit-learn.org/stable/modules/generated/ > sklearn.neighbors.BallTree.html > > Hope that helps, > Ed > > > On 20 May 2018 at 17:49, ashwin .D wrote: > >> Hi David, >> Many thanks for your prompt response and that maybe the >> route that I may have to take eventually. I was just wondering whether >> scipy has any equivalent for the stuff described in this paper - >> http://www.soest.hawaii.edu/wessel/sphspline/Wessel+Becker_2008_GJI.pdf ? >> >> Regards, >> Ashwin. >> >> On Sun, May 20, 2018 at 9:56 PM, David Hoese wrote: >> >>> Hi Ashwin, >>> >>> As far as I know this is the easiest way to do it. I'm not a scipy >>> developer, but you may be interested in the pyresample package: >>> >>> http://pyresample.readthedocs.io/en/latest/ >>> >>> Which uses the pykdtree library: >>> >>> https://github.com/storpipfugl/pykdtree >>> >>> And can perform resampling of irregularly spaced data. For certain >>> calculations/utilities it will also convert to XYZ space as described in >>> that SO answer. Hope this helps a little, sorry if it isn't the answer >>> you're looking for. >>> >>> Dave >>> >>> >>> On 5/20/18 11:09 AM, ashwin .D wrote: >>> >>>> Hello, >>>> I am using - https://docs.scipy.org/doc/sci >>>> py/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree >>>> which I believe is using Euclidean distances underneath the hood. But I >>>> want to be able to use great circle distances. Is this the only way to do >>>> this - https://stackoverflow.com/questions/20654918/python-how-to-s >>>> peed-up-calculation-of-distances-between-cities or is there some way I >>>> can extend that class to use great circle distances(maybe somebody has >>>> already done that ? ) I have a irregular shaped grid in a WGS 84 >>>> ellipsoid(can be assumed to be a sphere) and so I want to use great circle >>>> distances or if somebody can convince me not to that would be great as well. >>>> >>>> >>>> Best regards, >>>> Ashwin. >>>> >>>> >>>> _______________________________________________ >>>> SciPy-User mailing list >>>> SciPy-User at python.org >>>> https://mail.python.org/mailman/listinfo/scipy-user >>>> >>>> _______________________________________________ >>> SciPy-User mailing list >>> SciPy-User at python.org >>> https://mail.python.org/mailman/listinfo/scipy-user >>> >> >> >> _______________________________________________ >> SciPy-User mailing list >> SciPy-User at python.org >> https://mail.python.org/mailman/listinfo/scipy-user >> >> > > > -- > Public key available at pgp.mit.edu > , > ID:B30279BC > > _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From chris.barker at noaa.gov Mon May 21 19:43:49 2018 From: chris.barker at noaa.gov (Chris Barker) Date: Mon, 21 May 2018 16:43:49 -0700 Subject: [SciPy-User] KD Tree with great circle distances In-Reply-To: References: <9f507da2-dd90-fc8c-d9ee-fa3b5e1e0c8e@gmail.com> Message-ID: can't help working if great circle distance matters. sure, it's a different value than euclidean distance, but for finding neighbors, the absolute value doesn't matter, only the relative distances -- and locally, relative distances may be close enough. just a thought... -CHB On Sun, May 20, 2018 at 6:35 PM, ashwin .D wrote: > Hi Ed, > I believe it is indeed very helpful and I may end up using > either the VP tree or the Ball tree. In order to give you few more details > I have data on a WGS 84 ellipsoid(we can assume this to be a sphere) from > 66 N to 66 S and all the longitudes. The data is three dimensional but is > equidistant along the third dimension i.e. height. The data is also highly > sparse. From a flattened version of the 3d array I have 22163680 points and > out of that only 266111 points have finite values(greater than zero). The > rest are all NaNs.But the finite data(those values that are greater than > zero) is clustered i.e. possibly very close to each other. The resolution > horizontally is around 5 kms. What I intend to do is to 2D interpolation > for each height level. > > Best regards, > Ashwin. > > > > On Mon, May 21, 2018 at 1:27 AM, Edward Gryspeerdt > wrote: > >> Hi Ashwin, >> >> If you are using the whole globe, you might want to consider using >> something like a VP-tree instead. A KD-tree needs left/right to be >> defined, which you can't do on a sphere. >> >> Scikit-learn has a BallTree, which you can use with a 'haversine' >> distance metric, which should allow you to do do nearest neighbours on a >> sphere >> >> http://scikit-learn.org/stable/modules/generated/sklearn. >> neighbors.BallTree.html >> >> Hope that helps, >> Ed >> >> >> On 20 May 2018 at 17:49, ashwin .D wrote: >> >>> Hi David, >>> Many thanks for your prompt response and that maybe the >>> route that I may have to take eventually. I was just wondering whether >>> scipy has any equivalent for the stuff described in this paper - >>> http://www.soest.hawaii.edu/wessel/sphspline/Wessel+Becker_2008_GJI.pdf >>> ? >>> >>> Regards, >>> Ashwin. >>> >>> On Sun, May 20, 2018 at 9:56 PM, David Hoese wrote: >>> >>>> Hi Ashwin, >>>> >>>> As far as I know this is the easiest way to do it. I'm not a scipy >>>> developer, but you may be interested in the pyresample package: >>>> >>>> http://pyresample.readthedocs.io/en/latest/ >>>> >>>> Which uses the pykdtree library: >>>> >>>> https://github.com/storpipfugl/pykdtree >>>> >>>> And can perform resampling of irregularly spaced data. For certain >>>> calculations/utilities it will also convert to XYZ space as described in >>>> that SO answer. Hope this helps a little, sorry if it isn't the answer >>>> you're looking for. >>>> >>>> Dave >>>> >>>> >>>> On 5/20/18 11:09 AM, ashwin .D wrote: >>>> >>>>> Hello, >>>>> I am using - https://docs.scipy.org/doc/sci >>>>> py/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree >>>>> which I believe is using Euclidean distances underneath the hood. But I >>>>> want to be able to use great circle distances. Is this the only way to do >>>>> this - https://stackoverflow.com/questions/20654918/python-how-to-s >>>>> peed-up-calculation-of-distances-between-cities or is there some way >>>>> I can extend that class to use great circle distances(maybe somebody has >>>>> already done that ? ) I have a irregular shaped grid in a WGS 84 >>>>> ellipsoid(can be assumed to be a sphere) and so I want to use great circle >>>>> distances or if somebody can convince me not to that would be great as well. >>>>> >>>>> >>>>> Best regards, >>>>> Ashwin. >>>>> >>>>> >>>>> _______________________________________________ >>>>> SciPy-User mailing list >>>>> SciPy-User at python.org >>>>> https://mail.python.org/mailman/listinfo/scipy-user >>>>> >>>>> _______________________________________________ >>>> SciPy-User mailing list >>>> SciPy-User at python.org >>>> https://mail.python.org/mailman/listinfo/scipy-user >>>> >>> >>> >>> _______________________________________________ >>> SciPy-User mailing list >>> SciPy-User at python.org >>> https://mail.python.org/mailman/listinfo/scipy-user >>> >>> >> >> >> -- >> Public key available at pgp.mit.edu >> , >> ID:B30279BC >> >> _______________________________________________ >> SciPy-User mailing list >> SciPy-User at python.org >> https://mail.python.org/mailman/listinfo/scipy-user >> >> > > _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > > -- Christopher Barker, Ph.D. Oceanographer Emergency Response Division NOAA/NOS/OR&R (206) 526-6959 voice 7600 Sand Point Way NE (206) 526-6329 fax Seattle, WA 98115 (206) 526-6317 main reception Chris.Barker at noaa.gov -------------- next part -------------- An HTML attachment was scrubbed... URL: From yc-153434 at hs-weingarten.de Fri May 25 04:27:39 2018 From: yc-153434 at hs-weingarten.de (yc-153434 at hs-weingarten.de) Date: Fri, 25 May 2018 10:27:39 +0200 Subject: [SciPy-User] Multibody Vehicle Dynamic Simulation Message-ID: <2146681.Bh3HiB8GG9@kdeneon> Dear Scipy-Users, I am a student from Germany and I'm new to Scipy. It would be nice if you could help me out with your recommendations for the following project: I am planing to do a *vehicle dynamic simulation with a multibody system for a race car*. The suspension of the car is very simple and the whole car can be simplified. *Goal:* The vehicle should automatically follow a given path/trajectory (which is the racing line of a racing track) at the maximum possible speed/acceleration. I want to optimize some suspension parameters to get the minimum lap time of the given path/trajectory. This is called a lap time simulation. It should be possible to visualize the car in a (simple) 3D Model. *The conditions for this project:* I have time of 5 months for this project. I am a bachelor student of automotive engineering. I am working full time on this project. I am willing to do programming. I have some basic experiences in python and i have installed the anaconda distribution on a Linux distribution. I have basic knowledge of kinematics/dynamics. *Some doubts and questions that i have:* 1. In general: is it possible and advisable to do this in python? If not, which free software would you recommend? MBDyn? GNU Octave? SciLab? OpenModellica? MBSymba? 2. Which python environment (for Linux) would you recommend for programming? Spyder? Jupyter Notebook? 3. Which software would you recommend for visualization? 4. Which package should I use for the multibody approach? PyDy? SymPy? 5. How should I model the tires? With OpenTyre? 6. Which book is recommendable for my project? "The Multibody Systems Approach to Vehicle Dynamics" by Mike Blundell? Do you know any other source of information which could be helpful for me? 7. Do you think I can handle this project in the given time? Thanks a lot! Greetings -------------- next part -------------- An HTML attachment was scrubbed... URL: From mikofski at berkeley.edu Fri May 25 12:32:47 2018 From: mikofski at berkeley.edu (Mark Alexander Mikofski) Date: Fri, 25 May 2018 09:32:47 -0700 Subject: [SciPy-User] Multibody Vehicle Dynamic Simulation In-Reply-To: <2146681.Bh3HiB8GG9@kdeneon> References: <2146681.Bh3HiB8GG9@kdeneon> Message-ID: Hi and thanks for your interest in SciPy and Python. My responses corresponded to your number questions: 1. In my humble opinion Python with NumPy (http://www.numpy.org/) is especially well suited to your problem (of the multibody vehicle dynamic simulation), although other tools would also serve you well: - MATLAB (by the Mathworks) although expensive, and costly for additional toolboxes is sometimes sold at a reduced price, or offered free, to colleges, so you should check if this is already available. It has a just in time compiler, extensive documentation, and online support - Python is FREE, almost all of the useful additional packages are also FREE (such as NumPy, SciPy, Numba, Cython), it also has a JIT compiler (Numba), although most documentation is extensive, it isn't consistent for every package since there are different developers usually volunteering, however online support for Python and Python packages (such as this forum) is in my opinion just as good or better than MATLAB. Typically you will find most answers either on StackOverflow, in a user forum or IRC/Slack channel, or on GitHub, however it is important to remember to be patient and respectful of others time, since they are not paid to respond to your questions or issues. You can also pay for online Python support from Anaconda (https://www.anaconda.com/support/) and Enthought ( https://www.enthought.com/) - I think you will have a hard time with Octave or SciLab, not sure about the rest. - Julia (https://julialang.org/) is a new scientific computing language that you might consider, although IMHO, Python will be an easier path b/c it is more mature, more widely used, more support, and more packages. 2. I think you should use Spyder for developing modules and packages that form a reusable project. And then you can write scripts and reports with graphics, text, and equations in Jupyter notebooks so you can share them with others - For example: you could develop a package in Spyder called racetrack that contains classes like car, track, and all of your physics like forces with centrifugal, gravity, and friction. Then in a Jupyter notebook you could import racetrack and use it to simulate a race car and optimize its speed and steering to minimize its time around the track. You can demonstrate the equations and display plots and images in the notebook, export it as HTML or pdf and share it with others. - Make sure you keep everything in a Git repository, then mirror your repo online. I personally like GitHub, but Bitbucket and GitLab are also fine. 3. Depends on what type of visualization. For plots and charts, matplotlib and seaborn are good, Bokeh is great for interactive plots, altair and holoview and good for descriptive (vs. imperative) datavis, this is a new concept where you let the software decide the best way to represent your data, rather than make commands about ever property of the plot. - for 3-d car simulations, I think you would have to try something like sketchup (https://www.sketchup.com/) which uses Ruby I think 4. It appears to me that PyDy actually uses SymPy already for algebraic manipulation, so in using PyDy you would also be using SymPy. - looking at the PyDy site it hasn't been developed in over 2 years, that doesn't mean that it isn't any good, but it may mean that you may have difficulty getting support. - perhaps you can consider this as an opportunity to revive PyDy and make some contributions to improve it or bring it up to date? - fork PyDy on GitHub https://github.com/pydy, create a conda environment without PyDy installed, and do a developer/editable install (pip install -e or python setup.py develop see https://pip.pypa.io/en/ stable/reference/pip_install/ or http://setuptools. readthedocs.io/en/latest/setuptools.html#development-mode ), you can install the official version in a fresh conda environment either from PyPI (https://pypi.org/project/pydy/) using pip or from conda-forge (https://conda-forge.org/feedstocks/) using conda -c conda-forge ... - If you were to choose SymPy, which is only for algebraic manipulation, then you would have to develop all of the dynamic equations from scratch, which has already been done in PyDy, so you might be duplicating work already done, and your efforts might be better used improving what already exists? 5. 5-6 I think you're going to have to figure these out on your own, maybe someone else will have some opinions. Try Stack Exchange? I know that some racing teams are already using Python to analyze their cars, so if you keep searching I bet you will come across them. Maybe go to some car races and ask in the pit? Good luck and happy coding! On Fri, May 25, 2018 at 1:27 AM, wrote: > Dear Scipy-Users, > > > > I am a student from Germany and I'm new to Scipy. > > It would be nice if you could help me out with your recommendations for > the following project: > > > > I am planing to do a vehicle dynamic simulation with a multibody system > for a race car. The suspension of the car is very simple and the whole > car can be simplified. > > > > Goal: > > The vehicle should automatically follow a given path/trajectory (which is > the racing line of a racing track) at the maximum possible > speed/acceleration. > > I want to optimize some suspension parameters to get the minimum lap time > of the given path/trajectory. This is called a lap time simulation. > > It should be possible to visualize the car in a (simple) 3D Model. > > > > The conditions for this project: > > I have time of 5 months for this project. I am a bachelor student of > automotive engineering. I am working full time on this project. I am > willing to do programming. I have some basic experiences in python and i > have installed the anaconda distribution on a Linux distribution. I have > basic knowledge of kinematics/dynamics. > > > > Some doubts and questions that i have: > > 1. In general: is it possible and advisable to do this in python? If not, > which free software would you recommend? MBDyn? GNU Octave? SciLab? > OpenModellica? MBSymba? > > 2. Which python environment (for Linux) would you recommend for > programming? Spyder? Jupyter Notebook? > > 3. Which software would you recommend for visualization? > > 4. Which package should I use for the multibody approach? PyDy? SymPy? > > 5. How should I model the tires? With OpenTyre? > > 6. Which book is recommendable for my project? "The Multibody Systems > Approach to Vehicle Dynamics" by Mike Blundell? Do you know any other > source of information which could be helpful for me? > > 7. Do you think I can handle this project in the given time? > > > > Thanks a lot! > > Greetings > > > > _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > > -- Mark Mikofski, PhD (2005) *Fiat Lux* -------------- next part -------------- An HTML attachment was scrubbed... URL: From iamthemessie at gmail.com Fri May 25 13:51:53 2018 From: iamthemessie at gmail.com (The Messie) Date: Fri, 25 May 2018 19:51:53 +0200 Subject: [SciPy-User] Multibody Vehicle Dynamic Simulation In-Reply-To: <2146681.Bh3HiB8GG9@kdeneon> References: <2146681.Bh3HiB8GG9@kdeneon> Message-ID: Hello, 1. 3. and 4. You can use Panda3D for the simulation which comes bundled with its flavor of pyODE (Open Dynamic Engine) and adequate documentation to be useable. Additionally, you can visualize your car very easily using its rendering process. More on https://www.panda3d.org/ PyDy and SymPy in my opinion are not suitable for such complicated tasks, but again it depends on how detailed you want your model to be, maybe you can work something out if you simplify your model to 2 dimensions only (ignore pitch, roll etc.). Far easier would be to use TORCS which is inherently thought to be used for such purposes, or its evolution a.k.a. Speed Dreams. The model used for the simulation is not a dynamics simulation but rather simply calculating the equations of motion, but it is also capable for calculating advanced movements of the tires and body. 2. Personally I use linux with Spyder but other solutions work equally well. 5. Tire modeling: Use the Pajecka function for fitting your data (if you have some). SciPy should be more than adequate for that. However you have to figure out how to import the equations in the dynamics engine, usually contact physics of tyres are too advanced for any dynamics package to handle. E.g. ODE has simply a static and a dynamic friction coefficient, which is mostly enough for normal purposes, but for racing simulation may be inadequate. 6. The book you mention is quite good. Tyre vehicle dynamics by Pacejka is also good for knowledge on the tyres (after all most of the work on the car is done to make sure that can transfer the power to the road through the tires). However there is no book to my knowledge that provides the full set of equations of motion of a vehicle. 7. ?? it's up to you I guess. Not an easy task for sure. Regards, Thanass depending on the feats you wish to havis On Fri, May 25, 2018 at 10:27 AM, wrote: > Dear Scipy-Users, > > > > I am a student from Germany and I'm new to Scipy. > > It would be nice if you could help me out with your recommendations for > the following project: > > > > I am planing to do a vehicle dynamic simulation with a multibody system > for a race car. The suspension of the car is very simple and the whole > car can be simplified. > > > > Goal: > > The vehicle should automatically follow a given path/trajectory (which is > the racing line of a racing track) at the maximum possible > speed/acceleration. > > I want to optimize some suspension parameters to get the minimum lap time > of the given path/trajectory. This is called a lap time simulation. > > It should be possible to visualize the car in a (simple) 3D Model. > > > > The conditions for this project: > > I have time of 5 months for this project. I am a bachelor student of > automotive engineering. I am working full time on this project. I am > willing to do programming. I have some basic experiences in python and i > have installed the anaconda distribution on a Linux distribution. I have > basic knowledge of kinematics/dynamics. > > > > Some doubts and questions that i have: > > 1. In general: is it possible and advisable to do this in python? If not, > which free software would you recommend? MBDyn? GNU Octave? SciLab? > OpenModellica? MBSymba? > > 2. Which python environment (for Linux) would you recommend for > programming? Spyder? Jupyter Notebook? > > 3. Which software would you recommend for visualization? > > 4. Which package should I use for the multibody approach? PyDy? SymPy? > > 5. How should I model the tires? With OpenTyre? > > 6. Which book is recommendable for my project? "The Multibody Systems > Approach to Vehicle Dynamics" by Mike Blundell? Do you know any other > source of information which could be helpful for me? > > 7. Do you think I can handle this project in the given time? > > > > Thanks a lot! > > Greetings > > > > _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From er.gauravsinha at gmail.com Mon May 28 00:21:36 2018 From: er.gauravsinha at gmail.com (gaurav sinha) Date: Mon, 28 May 2018 09:51:36 +0530 Subject: [SciPy-User] Guidance required for automation of Excel work and Data Sciences Message-ID: Dear Experts Greetings!! *About me- I am Telecom professional having ~10 years of experience in 2G/3G/4G mobile technologies. * *I have selected Python as my Programming Language. Its been some time, I stared to learn and work in Python. * *Subject*- Guidance required for automation of Excel work and suggestion for Data Sciences. *Goal*- We have lots of parameters, spreed in many excel files (raw excel files having different parameter on data/time basis). I have to make a customized Excel sheet from these raw excel sheet having data (parameters vs data) which can be used as one button solution. I mean to say that, just we need to fetch the excel reports (raw) and put in a folder and just press one button/script file to generate our final report. Please suggest how to proceed. Also please suggest how to master the Python in the filed of Data Sciences. Thanks a lot!! * BR//GAURAV SINHA* -------------- next part -------------- An HTML attachment was scrubbed... URL: From matthew.brett at gmail.com Mon May 28 07:40:28 2018 From: matthew.brett at gmail.com (Matthew Brett) Date: Mon, 28 May 2018 12:40:28 +0100 Subject: [SciPy-User] Guidance required for automation of Excel work and Data Sciences In-Reply-To: References: Message-ID: Hi, On Mon, May 28, 2018 at 5:21 AM, gaurav sinha wrote: > Dear Experts > Greetings!! > > About me- I am Telecom professional having ~10 years of experience in > 2G/3G/4G mobile technologies. > > I have selected Python as my Programming Language. Its been some time, I > stared to learn and work in Python. > > Subject- Guidance required for automation of Excel work and suggestion for > Data Sciences. > > Goal- We have lots of parameters, spreed in many excel files (raw excel > files having different parameter on data/time basis). > I have to make a customized Excel sheet from these raw excel sheet having > data (parameters vs data) which can be used as one button solution. I mean > to say that, just we need to fetch the excel reports (raw) and put in a > folder and just press one button/script file to generate our final report. > > Please suggest how to proceed. > > Also please suggest how to master the Python in the filed of Data Sciences. You're currently on the Scipy mailing list; Scipy is a library of numerical routines, often used by other libraries that have a stronger link to data science, particularly Pandas, and scikit-learn. As a first pass, I suggest you try over at the Pandas mailing list, and you might want to start with this book, to get going: http://wesmckinney.com/pages/book.html Cheers, Matthew From ben.v.root at gmail.com Mon May 28 09:13:02 2018 From: ben.v.root at gmail.com (Benjamin Root) Date: Mon, 28 May 2018 09:13:02 -0400 Subject: [SciPy-User] Guidance required for automation of Excel work and Data Sciences In-Reply-To: References: Message-ID: the openpyxl package will be your friend. Here is a whole chapter on using it: https://automatetheboringstuff.com/chapter12/ Welcome to python! Ben Root On Mon, May 28, 2018 at 12:21 AM, gaurav sinha wrote: > Dear Experts > Greetings!! > > *About me- I am Telecom professional having ~10 years of experience in > 2G/3G/4G mobile technologies. * > > *I have selected Python as my Programming Language. Its been some time, I > stared to learn and work in Python. * > > *Subject*- Guidance required for automation of Excel work and suggestion > for Data Sciences. > > *Goal*- We have lots of parameters, spreed in many excel files (raw excel > files having different parameter on data/time basis). > I have to make a customized Excel sheet from these raw excel sheet having > data (parameters vs data) which can be used as one button solution. I mean > to say that, just we need to fetch the excel reports (raw) and put in a > folder and just press one button/script file to generate our final report. > > Please suggest how to proceed. > > Also please suggest how to master the Python in the filed of Data > Sciences. > > Thanks a lot!! > > > > > * BR//GAURAV SINHA* > > _______________________________________________ > SciPy-User mailing list > SciPy-User at python.org > https://mail.python.org/mailman/listinfo/scipy-user > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From egor.v.panfilov at gmail.com Tue May 29 05:09:38 2018 From: egor.v.panfilov at gmail.com (Egor Panfilov) Date: Tue, 29 May 2018 12:09:38 +0300 Subject: [SciPy-User] Scikit-image 0.14.0 release [cross-listed] Message-ID: Hello list, On behalf of `scikit-image` team I'm happy to announce the release of `scikit-image` version 0.14.0 ! This release brings a lot of exciting additions (such as new segmentation tools and algorithms, new datasets and data generating routines), various enhancements (nD support for image moments and regionprops, rescale, resize and pyramid_* function, multichannel support for HOG, multiple performance improvements, and many more) and a number of bugfixes to the code and to the documentation. I am also pleased to inform you that 0.14.x is the last major release with official support for Python 2.7. In order to make the transition to Python 3.x smooth for all the users we're making this release a long-term support one (it will receive important bugfixes and backports for approx. 2 years, following the Python 2.7 end-of-life cycle). For more details on the changes and additions, please, refer to the release notes [1]. I'd like to thank all the developers of the library for their hard work, and all the users for staying with us! Regards, Egor Panfilov, scikit-image core team .. [1] https://github.com/scikit-image/scikit-image/blob/v0.14.x/doc/release/release_0.14.rst .. [2] https://pypi.org/project/scikit-image/ -------------- next part -------------- An HTML attachment was scrubbed... URL: From valerio.maggio at gmail.com Tue May 29 05:57:48 2018 From: valerio.maggio at gmail.com (Valerio Maggio) Date: Tue, 29 May 2018 11:57:48 +0200 Subject: [SciPy-User] ANN: EuroScipy 2018 Message-ID: *** Apologies if you receive multiple copies *** Dear Colleagues, We are delighted to invite you to join us for the **11th European Conference on Python in Science**. The EuroSciPy 2018 (https://www.euroscipy.org/2018/) Conference will be organised by Fondazione Bruno Kessler (FBK) and will take place from August 28 to September 1 in **Trento, Italy**. The EuroSciPy meeting is a cross-disciplinary gathering focused on the use and development of the Python language in scientific research. This event strives to bring together both users and developers of scientific tools, as well as academic research and state of the art industry. The conference will be structured as it follows: Aug, 28-29 : Tutorials and Hands-on Aug, 30-31 : Main Conference Sep, 1 : Sprint TOPICS OF INTEREST: =================== Presentations of scientific tools and libraries using the Python language, including but not limited to: - Algorithms implemented or exposed in Python - Astronomy - Data Visualisation - Deep Learning & AI - Earth, Ocean and Geo Science - General-purpose Python tools that can be of special interest to the scientific community. - Image Processing - Materials Science - Parallel computing - Political and Social Sciences - Project Jupyter - Reports on the use of Python in scientific achievements or ongoing projects. - Robotics & IoT - Scientific data flow and persistence - Scientific visualization - Simulation - Statistics - Vector and array manipulation - Web applications and portals for science and engineering - 3D Printing CALL FOR PROPOSALS: =================== EuroScipy will accept three different kinds of contributions: * Regular Talks: standard talks for oral presentations, allocated in time slots of 15, or 30 minutes, depending on your preference and scheduling constraints. Each time slot considers a Q&A session at the end of the talk (at least, 5 mins). * Hands-on Tutorials: These are beginner or advanced training sessions to dive into the subject with all details. These sessions are 90 minutes long, and the audience will be strongly encouraged to bring a laptop to experiment. * Poster: EuroScipy will host two poster sessions during the two days of Main Conference. So attendees and students are highly encourage to present their work and/or preliminary results as posters. Proposals should be submitted using the EuroScipy submission system at https://pretalx.com/euroscipy18. **Submission deadline is May, 31st 2018**. REGISTRATION & FEES: ==================== To register to EuroScipy 2018, please go to http://euroscipy2018.eventbrite.co.uk or to http://www.euroscipy.org/2018/ Fees: ----- | Tutorials | Student* | Academic/Individual | Industry| |-----------------------------|----------|---------------------|----------| | Early Bird (till July, 1st) | ? 50,00 | ? 70,00 | ? 125,00 | | Regular (till Aug, 5th | ? 100,00 | ? 110,00 | ? 250,00 | | Late (till Aug, 22nd) | ? 135,00 | ? 135,00 | ? 300,00 | | Main Conference | Student* | Academic/Individual | Industry| |-----------------------------|----------|---------------------|----------| | Early Bird (till July, 1st) | ? 50,00 | ? 70,00 | ? 125,00 | | Regular (till Aug, 5th | ? 100,00 | ? 110,00 | ? 250,00 | | Late (till Aug, 22nd) | ? 135,00 | ? 135,00 | ? 300,00 | * A proof of student status will be required at time of the registration. kind regards, Valerio EuroScipy 2018 Organising Committee, Email: info at euroscipy.org Website: http://www.euroscipy.org/2018 twitter: @euroscipy -------------- next part -------------- An HTML attachment was scrubbed... URL: From sepand.haghighi at yahoo.com Thu May 31 17:35:51 2018 From: sepand.haghighi at yahoo.com (Sepand Haghighi) Date: Thu, 31 May 2018 21:35:51 +0000 (UTC) Subject: [SciPy-User] PyCM: Multiclass confusion matrix library in Python References: <2035307540.874140.1527802551592.ref@mail.yahoo.com> Message-ID: <2035307540.874140.1527802551592@mail.yahoo.com> PyCM is a multi-class confusion matrix library written in Python that supports both input data vectors and direct matrix, and a proper tool for post-classification model evaluation that supports most classes and overall statistics parameters. PyCM is the swiss-army knife of confusion matrices, targeted mainly at data scientists that need a broad array of metrics for predictive models and an accurate evaluation of large variety of classifiers. Github Repo :?https://github.com/sepandhaghighi/pycm Webpage :?http://pycm.shaghighi.ir/? JOSS Paper :?https://doi.org/10.21105/joss.00729 -------------- next part -------------- An HTML attachment was scrubbed... URL: