├── .gitignore ├── README.md ├── dist ├── lambda_handler.py ├── numpy-1.11.2.dist-info │ ├── DESCRIPTION.rst │ ├── INSTALLER │ ├── METADATA │ ├── RECORD │ ├── WHEEL │ ├── metadata.json │ └── top_level.txt └── numpy │ ├── .libs │ └── libgfortran-ed201abd.so.3.0.0 │ ├── __config__.py │ ├── __config__.pyc │ ├── __init__.py │ ├── __init__.pyc │ ├── _globals.py │ ├── _globals.pyc │ ├── _import_tools.py │ ├── _import_tools.pyc │ ├── add_newdocs.py │ ├── add_newdocs.pyc │ ├── compat │ ├── __init__.py │ ├── __init__.pyc │ ├── _inspect.py │ ├── _inspect.pyc │ ├── py3k.py │ ├── py3k.pyc │ ├── setup.py │ └── setup.pyc │ ├── core │ ├── __init__.py │ ├── __init__.pyc │ ├── _internal.py │ ├── _internal.pyc │ ├── _methods.py │ ├── _methods.pyc │ ├── arrayprint.py │ ├── arrayprint.pyc │ ├── cversions.py │ ├── cversions.pyc │ ├── defchararray.py │ ├── defchararray.pyc │ ├── fromnumeric.py │ ├── fromnumeric.pyc │ ├── function_base.py │ ├── function_base.pyc │ ├── generate_numpy_api.py │ ├── generate_numpy_api.pyc │ ├── getlimits.py │ ├── getlimits.pyc │ ├── include │ │ └── numpy │ │ │ ├── __multiarray_api.h │ │ │ ├── __ufunc_api.h │ │ │ ├── _neighborhood_iterator_imp.h │ │ │ ├── _numpyconfig.h │ │ │ ├── arrayobject.h │ │ │ ├── arrayscalars.h │ │ │ ├── halffloat.h │ │ │ ├── multiarray_api.txt │ │ │ ├── ndarrayobject.h │ │ │ ├── ndarraytypes.h │ │ │ ├── noprefix.h │ │ │ ├── npy_1_7_deprecated_api.h │ │ │ ├── npy_3kcompat.h │ │ │ ├── npy_common.h │ │ │ ├── npy_cpu.h │ │ │ ├── npy_endian.h │ │ │ ├── npy_interrupt.h │ │ │ ├── npy_math.h │ │ │ ├── npy_no_deprecated_api.h │ │ │ ├── npy_os.h │ │ │ ├── numpyconfig.h │ │ │ ├── old_defines.h │ │ │ ├── oldnumeric.h │ │ │ ├── ufunc_api.txt │ │ │ ├── ufuncobject.h │ │ │ └── utils.h │ ├── info.py │ ├── info.pyc │ ├── lib │ │ ├── libnpymath.a │ │ └── npy-pkg-config │ │ │ ├── mlib.ini │ │ │ └── npymath.ini │ ├── machar.py │ ├── machar.pyc │ ├── memmap.py │ ├── memmap.pyc │ ├── numeric.py │ ├── numeric.pyc │ ├── numerictypes.py │ ├── numerictypes.pyc │ ├── records.py │ ├── records.pyc │ ├── setup.py │ ├── setup.pyc │ ├── setup_common.py │ ├── setup_common.pyc │ ├── shape_base.py │ ├── shape_base.pyc │ └── tests │ │ ├── data │ │ ├── astype_copy.pkl │ │ └── recarray_from_file.fits │ │ ├── test_abc.py │ │ ├── test_abc.pyc │ │ ├── test_api.py │ │ ├── test_api.pyc │ │ ├── test_arrayprint.py │ │ ├── test_arrayprint.pyc │ │ ├── test_datetime.py │ │ ├── test_datetime.pyc │ │ ├── test_defchararray.py │ │ ├── test_defchararray.pyc │ │ ├── test_deprecations.py │ │ ├── test_deprecations.pyc │ │ ├── test_dtype.py │ │ ├── test_dtype.pyc │ │ ├── test_einsum.py │ │ ├── test_einsum.pyc │ │ ├── test_errstate.py │ │ ├── test_errstate.pyc │ │ ├── test_extint128.py │ │ ├── test_extint128.pyc │ │ ├── test_function_base.py │ │ ├── test_function_base.pyc │ │ ├── test_getlimits.py │ │ ├── test_getlimits.pyc │ │ ├── test_half.py │ │ ├── test_half.pyc │ │ ├── test_indexerrors.py │ │ ├── test_indexerrors.pyc │ │ ├── test_indexing.py │ │ ├── test_indexing.pyc │ │ ├── test_item_selection.py │ │ ├── test_item_selection.pyc │ │ ├── test_longdouble.py │ │ ├── test_longdouble.pyc │ │ ├── test_machar.py │ │ ├── test_machar.pyc │ │ ├── test_mem_overlap.py │ │ ├── test_mem_overlap.pyc │ │ ├── test_memmap.py │ │ ├── test_memmap.pyc │ │ ├── test_multiarray.py │ │ ├── test_multiarray.pyc │ │ ├── test_nditer.py │ │ ├── test_nditer.pyc │ │ ├── test_numeric.py │ │ ├── test_numeric.pyc │ │ ├── test_numerictypes.py │ │ ├── test_numerictypes.pyc │ │ ├── test_print.py │ │ ├── test_print.pyc │ │ ├── test_records.py │ │ ├── test_records.pyc │ │ ├── test_regression.py │ │ ├── test_regression.pyc │ │ ├── test_scalarinherit.py │ │ ├── test_scalarinherit.pyc │ │ ├── test_scalarmath.py │ │ ├── test_scalarmath.pyc │ │ ├── test_scalarprint.py │ │ ├── test_scalarprint.pyc │ │ ├── test_shape_base.py │ │ ├── test_shape_base.pyc │ │ ├── test_ufunc.py │ │ ├── test_ufunc.pyc │ │ ├── test_umath.py │ │ ├── test_umath.pyc │ │ ├── test_umath_complex.py │ │ ├── test_umath_complex.pyc │ │ ├── test_unicode.py │ │ └── test_unicode.pyc │ ├── ctypeslib.py │ ├── ctypeslib.pyc │ ├── distutils │ ├── __config__.py │ ├── __config__.pyc │ ├── __init__.py │ ├── __init__.pyc │ ├── __version__.py │ ├── __version__.pyc │ ├── ccompiler.py │ ├── ccompiler.pyc │ ├── command │ │ ├── __init__.py │ │ ├── __init__.pyc │ │ ├── autodist.py │ │ ├── autodist.pyc │ │ ├── bdist_rpm.py │ │ ├── bdist_rpm.pyc │ │ ├── build.py │ │ ├── build.pyc │ │ ├── build_clib.py │ │ ├── build_clib.pyc │ │ ├── build_ext.py │ │ ├── build_ext.pyc │ │ ├── build_py.py │ │ ├── build_py.pyc │ │ ├── build_scripts.py │ │ ├── build_scripts.pyc │ │ ├── build_src.py │ │ ├── build_src.pyc │ │ ├── config.py │ │ ├── config.pyc │ │ ├── config_compiler.py │ │ ├── config_compiler.pyc │ │ ├── develop.py │ │ ├── develop.pyc │ │ ├── egg_info.py │ │ ├── egg_info.pyc │ │ ├── install.py │ │ ├── install.pyc │ │ ├── install_clib.py │ │ ├── install_clib.pyc │ │ ├── install_data.py │ │ ├── install_data.pyc │ │ ├── install_headers.py │ │ ├── install_headers.pyc │ │ ├── sdist.py │ │ └── sdist.pyc │ ├── compat.py │ ├── compat.pyc │ ├── conv_template.py │ ├── conv_template.pyc │ ├── core.py │ ├── core.pyc │ ├── cpuinfo.py │ ├── cpuinfo.pyc │ ├── environment.py │ ├── environment.pyc │ ├── exec_command.py │ ├── exec_command.pyc │ ├── extension.py │ ├── extension.pyc │ ├── fcompiler │ │ ├── __init__.py │ │ ├── __init__.pyc │ │ ├── absoft.py │ │ ├── absoft.pyc │ │ ├── compaq.py │ │ ├── compaq.pyc │ │ ├── g95.py │ │ ├── g95.pyc │ │ ├── gnu.py │ │ ├── gnu.pyc │ │ ├── hpux.py │ │ ├── hpux.pyc │ │ ├── ibm.py │ │ ├── ibm.pyc │ │ ├── intel.py │ │ ├── intel.pyc │ │ ├── lahey.py │ │ ├── lahey.pyc │ │ ├── mips.py │ │ ├── mips.pyc │ │ ├── nag.py │ │ ├── nag.pyc │ │ ├── none.py │ │ ├── none.pyc │ │ ├── pathf95.py │ │ ├── pathf95.pyc │ │ ├── pg.py │ │ ├── pg.pyc │ │ ├── sun.py │ │ ├── sun.pyc │ │ ├── vast.py │ │ └── vast.pyc │ ├── from_template.py │ ├── from_template.pyc │ ├── info.py │ ├── info.pyc │ ├── intelccompiler.py │ ├── intelccompiler.pyc │ ├── lib2def.py │ ├── lib2def.pyc │ ├── line_endings.py │ ├── line_endings.pyc │ ├── log.py │ ├── log.pyc │ ├── mingw │ │ └── gfortran_vs2003_hack.c │ ├── mingw32ccompiler.py │ ├── mingw32ccompiler.pyc │ ├── misc_util.py │ ├── misc_util.pyc │ ├── msvc9compiler.py │ ├── msvc9compiler.pyc │ ├── msvccompiler.py │ ├── msvccompiler.pyc │ ├── npy_pkg_config.py │ ├── npy_pkg_config.pyc │ ├── numpy_distribution.py │ ├── numpy_distribution.pyc │ ├── pathccompiler.py │ ├── pathccompiler.pyc │ ├── setup.py │ ├── setup.pyc │ ├── system_info.py │ ├── system_info.pyc │ ├── tests │ │ ├── test_exec_command.py │ │ ├── test_exec_command.pyc │ │ ├── test_fcompiler_gnu.py │ │ ├── test_fcompiler_gnu.pyc │ │ ├── test_fcompiler_intel.py │ │ ├── test_fcompiler_intel.pyc │ │ ├── test_misc_util.py │ │ ├── test_misc_util.pyc │ │ ├── test_npy_pkg_config.py │ │ ├── test_npy_pkg_config.pyc │ │ ├── test_system_info.py │ │ └── test_system_info.pyc │ ├── unixccompiler.py │ └── unixccompiler.pyc │ ├── doc │ ├── __init__.py │ ├── __init__.pyc │ ├── basics.py │ ├── basics.pyc │ ├── broadcasting.py │ ├── broadcasting.pyc │ ├── byteswapping.py │ ├── byteswapping.pyc │ ├── constants.py │ ├── constants.pyc │ ├── creation.py │ ├── creation.pyc │ ├── glossary.py │ ├── glossary.pyc │ ├── indexing.py │ ├── indexing.pyc │ ├── internals.py │ ├── internals.pyc │ ├── misc.py │ ├── misc.pyc │ ├── structured_arrays.py │ ├── structured_arrays.pyc │ ├── subclassing.py │ ├── subclassing.pyc │ ├── ufuncs.py │ └── ufuncs.pyc │ ├── dual.py │ ├── dual.pyc │ ├── f2py │ ├── __init__.py │ ├── __init__.pyc │ ├── __main__.py │ ├── __main__.pyc │ ├── __version__.py │ ├── __version__.pyc │ ├── auxfuncs.py │ ├── auxfuncs.pyc │ ├── capi_maps.py │ ├── capi_maps.pyc │ ├── cb_rules.py │ ├── cb_rules.pyc │ ├── cfuncs.py │ ├── cfuncs.pyc │ ├── common_rules.py │ ├── common_rules.pyc │ ├── crackfortran.py │ ├── crackfortran.pyc │ ├── diagnose.py │ ├── diagnose.pyc │ ├── f2py2e.py │ ├── f2py2e.pyc │ ├── f2py_testing.py │ ├── f2py_testing.pyc │ ├── f90mod_rules.py │ ├── f90mod_rules.pyc │ ├── func2subr.py │ ├── func2subr.pyc │ ├── info.py │ ├── info.pyc │ ├── rules.py │ ├── rules.pyc │ ├── setup.py │ ├── setup.pyc │ ├── src │ │ ├── fortranobject.c │ │ └── fortranobject.h │ ├── tests │ │ ├── src │ │ │ ├── array_from_pyobj │ │ │ │ └── wrapmodule.c │ │ │ ├── assumed_shape │ │ │ │ ├── .f2py_f2cmap │ │ │ │ ├── foo_free.f90 │ │ │ │ ├── foo_mod.f90 │ │ │ │ ├── foo_use.f90 │ │ │ │ └── precision.f90 │ │ │ ├── kind │ │ │ │ └── foo.f90 │ │ │ ├── mixed │ │ │ │ ├── foo.f │ │ │ │ ├── foo_fixed.f90 │ │ │ │ └── foo_free.f90 │ │ │ ├── regression │ │ │ │ └── inout.f90 │ │ │ └── size │ │ │ │ └── foo.f90 │ │ ├── test_array_from_pyobj.py │ │ ├── test_array_from_pyobj.pyc │ │ ├── test_assumed_shape.py │ │ ├── test_assumed_shape.pyc │ │ ├── test_callback.py │ │ ├── test_callback.pyc │ │ ├── test_kind.py │ │ ├── test_kind.pyc │ │ ├── test_mixed.py │ │ ├── test_mixed.pyc │ │ ├── test_regression.py │ │ ├── test_regression.pyc │ │ ├── test_return_character.py │ │ ├── test_return_character.pyc │ │ ├── test_return_complex.py │ │ ├── test_return_complex.pyc │ │ ├── test_return_integer.py │ │ ├── test_return_integer.pyc │ │ ├── test_return_logical.py │ │ ├── test_return_logical.pyc │ │ ├── test_return_real.py │ │ ├── test_return_real.pyc │ │ ├── test_size.py │ │ ├── test_size.pyc │ │ ├── util.py │ │ └── util.pyc │ ├── use_rules.py │ └── use_rules.pyc │ ├── fft │ ├── __init__.py │ ├── __init__.pyc │ ├── fftpack.py │ ├── fftpack.pyc │ ├── helper.py │ ├── helper.pyc │ ├── info.py │ ├── info.pyc │ ├── setup.py │ ├── setup.pyc │ └── tests │ │ ├── test_fftpack.py │ │ ├── test_fftpack.pyc │ │ ├── test_helper.py │ │ └── test_helper.pyc │ ├── lib │ ├── __init__.py │ ├── __init__.pyc │ ├── _datasource.py │ ├── _datasource.pyc │ ├── _iotools.py │ ├── _iotools.pyc │ ├── _version.py │ ├── _version.pyc │ ├── arraypad.py │ ├── arraypad.pyc │ ├── arraysetops.py │ ├── arraysetops.pyc │ ├── arrayterator.py │ ├── arrayterator.pyc │ ├── financial.py │ ├── financial.pyc │ ├── format.py │ ├── format.pyc │ ├── function_base.py │ ├── function_base.pyc │ ├── index_tricks.py │ ├── index_tricks.pyc │ ├── info.py │ ├── info.pyc │ ├── nanfunctions.py │ ├── nanfunctions.pyc │ ├── npyio.py │ ├── npyio.pyc │ ├── polynomial.py │ ├── polynomial.pyc │ ├── recfunctions.py │ ├── recfunctions.pyc │ ├── scimath.py │ ├── scimath.pyc │ ├── setup.py │ ├── setup.pyc │ ├── shape_base.py │ ├── shape_base.pyc │ ├── stride_tricks.py │ ├── stride_tricks.pyc │ ├── tests │ │ ├── data │ │ │ ├── py2-objarr.npy │ │ │ ├── py2-objarr.npz │ │ │ ├── py3-objarr.npy │ │ │ ├── py3-objarr.npz │ │ │ ├── python3.npy │ │ │ └── win64python2.npy │ │ ├── test__datasource.py │ │ ├── test__datasource.pyc │ │ ├── test__iotools.py │ │ ├── test__iotools.pyc │ │ ├── test__version.py │ │ ├── test__version.pyc │ │ ├── test_arraypad.py │ │ ├── test_arraypad.pyc │ │ ├── test_arraysetops.py │ │ ├── test_arraysetops.pyc │ │ ├── test_arrayterator.py │ │ ├── test_arrayterator.pyc │ │ ├── test_financial.py │ │ ├── test_financial.pyc │ │ ├── test_format.py │ │ ├── test_format.pyc │ │ ├── test_function_base.py │ │ ├── test_function_base.pyc │ │ ├── test_index_tricks.py │ │ ├── test_index_tricks.pyc │ │ ├── test_io.py │ │ ├── test_io.pyc │ │ ├── test_nanfunctions.py │ │ ├── test_nanfunctions.pyc │ │ ├── test_packbits.py │ │ ├── test_packbits.pyc │ │ ├── test_polynomial.py │ │ ├── test_polynomial.pyc │ │ ├── test_recfunctions.py │ │ ├── test_recfunctions.pyc │ │ ├── test_regression.py │ │ ├── test_regression.pyc │ │ ├── test_shape_base.py │ │ ├── test_shape_base.pyc │ │ ├── test_stride_tricks.py │ │ ├── test_stride_tricks.pyc │ │ ├── test_twodim_base.py │ │ ├── test_twodim_base.pyc │ │ ├── test_type_check.py │ │ ├── test_type_check.pyc │ │ ├── test_ufunclike.py │ │ ├── test_ufunclike.pyc │ │ ├── test_utils.py │ │ └── test_utils.pyc │ ├── twodim_base.py │ ├── twodim_base.pyc │ ├── type_check.py │ ├── type_check.pyc │ ├── ufunclike.py │ ├── ufunclike.pyc │ ├── user_array.py │ ├── user_array.pyc │ ├── utils.py │ └── utils.pyc │ ├── linalg │ ├── __init__.py │ ├── __init__.pyc │ ├── info.py │ ├── info.pyc │ ├── linalg.py │ ├── linalg.pyc │ ├── setup.py │ ├── setup.pyc │ └── tests │ │ ├── test_build.py │ │ ├── test_build.pyc │ │ ├── test_deprecations.py │ │ ├── test_deprecations.pyc │ │ ├── test_linalg.py │ │ ├── test_linalg.pyc │ │ ├── test_regression.py │ │ └── test_regression.pyc │ ├── ma │ ├── __init__.py │ ├── __init__.pyc │ ├── bench.py │ ├── bench.pyc │ ├── core.py │ ├── core.pyc │ ├── extras.py │ ├── extras.pyc │ ├── mrecords.py │ ├── mrecords.pyc │ ├── setup.py │ ├── setup.pyc │ ├── tests │ │ ├── test_core.py │ │ ├── test_core.pyc │ │ ├── test_extras.py │ │ ├── test_extras.pyc │ │ ├── test_mrecords.py │ │ ├── test_mrecords.pyc │ │ ├── test_old_ma.py │ │ ├── test_old_ma.pyc │ │ ├── test_regression.py │ │ ├── test_regression.pyc │ │ ├── test_subclassing.py │ │ └── test_subclassing.pyc │ ├── testutils.py │ ├── testutils.pyc │ ├── timer_comparison.py │ ├── timer_comparison.pyc │ ├── version.py │ └── version.pyc │ ├── matlib.py │ ├── matlib.pyc │ ├── matrixlib │ ├── __init__.py │ ├── __init__.pyc │ ├── defmatrix.py │ ├── defmatrix.pyc │ ├── setup.py │ ├── setup.pyc │ └── tests │ │ ├── test_defmatrix.py │ │ ├── test_defmatrix.pyc │ │ ├── test_multiarray.py │ │ ├── test_multiarray.pyc │ │ ├── test_numeric.py │ │ ├── test_numeric.pyc │ │ ├── test_regression.py │ │ └── test_regression.pyc │ ├── polynomial │ ├── __init__.py │ ├── __init__.pyc │ ├── _polybase.py │ ├── _polybase.pyc │ ├── chebyshev.py │ ├── chebyshev.pyc │ ├── hermite.py │ ├── hermite.pyc │ ├── hermite_e.py │ ├── hermite_e.pyc │ ├── laguerre.py │ ├── laguerre.pyc │ ├── legendre.py │ ├── legendre.pyc │ ├── polynomial.py │ ├── polynomial.pyc │ ├── polyutils.py │ ├── polyutils.pyc │ ├── setup.py │ ├── setup.pyc │ └── tests │ │ ├── test_chebyshev.py │ │ ├── test_chebyshev.pyc │ │ ├── test_classes.py │ │ ├── test_classes.pyc │ │ ├── test_hermite.py │ │ ├── test_hermite.pyc │ │ ├── test_hermite_e.py │ │ ├── test_hermite_e.pyc │ │ ├── test_laguerre.py │ │ ├── test_laguerre.pyc │ │ ├── test_legendre.py │ │ ├── test_legendre.pyc │ │ ├── test_polynomial.py │ │ ├── test_polynomial.pyc │ │ ├── test_polyutils.py │ │ ├── test_polyutils.pyc │ │ ├── test_printing.py │ │ └── test_printing.pyc │ ├── random │ ├── __init__.py │ ├── __init__.pyc │ ├── info.py │ ├── info.pyc │ ├── randomkit.h │ ├── setup.py │ ├── setup.pyc │ └── tests │ │ ├── test_random.py │ │ ├── test_random.pyc │ │ ├── test_regression.py │ │ └── test_regression.pyc │ ├── setup.py │ ├── setup.pyc │ ├── testing │ ├── __init__.py │ ├── __init__.pyc │ ├── decorators.py │ ├── decorators.pyc │ ├── noseclasses.py │ ├── noseclasses.pyc │ ├── nosetester.py │ ├── nosetester.pyc │ ├── print_coercion_tables.py │ ├── print_coercion_tables.pyc │ ├── setup.py │ ├── setup.pyc │ ├── tests │ │ ├── test_decorators.py │ │ ├── test_decorators.pyc │ │ ├── test_doctesting.py │ │ ├── test_doctesting.pyc │ │ ├── test_utils.py │ │ └── test_utils.pyc │ ├── utils.py │ └── utils.pyc │ ├── tests │ ├── test_ctypeslib.py │ ├── test_ctypeslib.pyc │ ├── test_matlib.py │ ├── test_matlib.pyc │ ├── test_numpy_version.py │ ├── test_numpy_version.pyc │ ├── test_reloading.py │ ├── test_reloading.pyc │ ├── test_scripts.py │ └── test_scripts.pyc │ ├── version.py │ └── version.pyc ├── docker └── Dockerfile └── src └── kernels.py /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | *.so 3 | *.zip 4 | -------------------------------------------------------------------------------- /dist/lambda_handler.py: -------------------------------------------------------------------------------- 1 | import kernels 2 | import numpy as np 3 | 4 | def run_demo(event, context): 5 | test_input_one = 4.0 6 | test_square = kernels.square(4) 7 | 8 | test_input_two = np.asarray([1.0, 2.0, 3.0]) 9 | test_square_array = kernels.squarearr(test_input_two) 10 | 11 | return { 12 | 'squared_number': test_square, 13 | 'squared_array': test_square_array.tolist() 14 | } 15 | 16 | # Uncomment this if you just want to run locally, i.e. 17 | # something like python lambda_handler.py, instead 18 | # of actually running in lambda 19 | if __name__ == '__main__': 20 | print run_demo(None, None) 21 | -------------------------------------------------------------------------------- /dist/numpy-1.11.2.dist-info/DESCRIPTION.rst: -------------------------------------------------------------------------------- 1 | NumPy is a general-purpose array-processing package designed to 2 | efficiently manipulate large multi-dimensional arrays of arbitrary 3 | records without sacrificing too much speed for small multi-dimensional 4 | arrays. NumPy is built on the Numeric code base and adds features 5 | introduced by numarray as well as an extended C-API and the ability to 6 | create arrays of arbitrary type which also makes NumPy suitable for 7 | interfacing with general-purpose data-base applications. 8 | 9 | There are also basic facilities for discrete fourier transform, 10 | basic linear algebra and random number generation. 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /dist/numpy-1.11.2.dist-info/INSTALLER: -------------------------------------------------------------------------------- 1 | pip 2 | -------------------------------------------------------------------------------- /dist/numpy-1.11.2.dist-info/METADATA: -------------------------------------------------------------------------------- 1 | Metadata-Version: 2.0 2 | Name: numpy 3 | Version: 1.11.2 4 | Summary: NumPy: array processing for numbers, strings, records, and objects. 5 | Home-page: http://www.numpy.org 6 | Author: NumPy Developers 7 | Author-email: numpy-discussion@scipy.org 8 | License: BSD 9 | Download-URL: http://sourceforge.net/projects/numpy/files/NumPy/ 10 | Platform: Windows 11 | Platform: Linux 12 | Platform: Solaris 13 | Platform: Mac OS-X 14 | Platform: Unix 15 | Classifier: Development Status :: 5 - Production/Stable 16 | Classifier: Intended Audience :: Science/Research 17 | Classifier: Intended Audience :: Developers 18 | Classifier: License :: OSI Approved 19 | Classifier: Programming Language :: C 20 | Classifier: Programming Language :: Python 21 | Classifier: Programming Language :: Python :: 2 22 | Classifier: Programming Language :: Python :: 2.6 23 | Classifier: Programming Language :: Python :: 2.7 24 | Classifier: Programming Language :: Python :: 3 25 | Classifier: Programming Language :: Python :: 3.2 26 | Classifier: Programming Language :: Python :: 3.3 27 | Classifier: Programming Language :: Python :: 3.4 28 | Classifier: Programming Language :: Python :: 3.5 29 | Classifier: Programming Language :: Python :: Implementation :: CPython 30 | Classifier: Topic :: Software Development 31 | Classifier: Topic :: Scientific/Engineering 32 | Classifier: Operating System :: Microsoft :: Windows 33 | Classifier: Operating System :: POSIX 34 | Classifier: Operating System :: Unix 35 | Classifier: Operating System :: MacOS 36 | 37 | NumPy is a general-purpose array-processing package designed to 38 | efficiently manipulate large multi-dimensional arrays of arbitrary 39 | records without sacrificing too much speed for small multi-dimensional 40 | arrays. NumPy is built on the Numeric code base and adds features 41 | introduced by numarray as well as an extended C-API and the ability to 42 | create arrays of arbitrary type which also makes NumPy suitable for 43 | interfacing with general-purpose data-base applications. 44 | 45 | There are also basic facilities for discrete fourier transform, 46 | basic linear algebra and random number generation. 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /dist/numpy-1.11.2.dist-info/WHEEL: -------------------------------------------------------------------------------- 1 | Wheel-Version: 1.0 2 | Generator: bdist_wheel (0.29.0) 3 | Root-Is-Purelib: false 4 | Tag: cp27-cp27mu-manylinux1_x86_64 5 | 6 | -------------------------------------------------------------------------------- /dist/numpy-1.11.2.dist-info/metadata.json: -------------------------------------------------------------------------------- 1 | {"classifiers": ["Development Status :: 5 - Production/Stable", "Intended Audience :: Science/Research", "Intended Audience :: Developers", "License :: OSI Approved", "Programming Language :: C", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.2", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: Implementation :: CPython", "Topic :: Software Development", "Topic :: Scientific/Engineering", "Operating System :: Microsoft :: Windows", "Operating System :: POSIX", "Operating System :: Unix", "Operating System :: MacOS"], "download_url": "http://sourceforge.net/projects/numpy/files/NumPy/", "extensions": {"python.details": {"contacts": [{"email": "numpy-discussion@scipy.org", "name": "NumPy Developers", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "http://www.numpy.org"}}}, "generator": "bdist_wheel (0.29.0)", "license": "BSD", "metadata_version": "2.0", "name": "numpy", "platform": "Windows", "summary": "NumPy: array processing for numbers, strings, records, and objects.", "version": "1.11.2"} -------------------------------------------------------------------------------- /dist/numpy-1.11.2.dist-info/top_level.txt: -------------------------------------------------------------------------------- 1 | numpy 2 | -------------------------------------------------------------------------------- /dist/numpy/.libs/libgfortran-ed201abd.so.3.0.0: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/.libs/libgfortran-ed201abd.so.3.0.0 -------------------------------------------------------------------------------- /dist/numpy/__config__.py: -------------------------------------------------------------------------------- 1 | # This file is generated by /tmp/pip-alns09-build/-c 2 | # It contains system_info results at the time of building this package. 3 | __all__ = ["get_info","show"] 4 | 5 | lapack_opt_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 6 | openblas_lapack_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 7 | blas_mkl_info={} 8 | openblas_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 9 | blas_opt_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 10 | 11 | def get_info(name): 12 | g = globals() 13 | return g.get(name, g.get(name + "_info", {})) 14 | 15 | def show(): 16 | for name,info_dict in globals().items(): 17 | if name[0] == "_" or type(info_dict) is not type({}): continue 18 | print(name + ":") 19 | if not info_dict: 20 | print(" NOT AVAILABLE") 21 | for k,v in info_dict.items(): 22 | v = str(v) 23 | if k == "sources" and len(v) > 200: 24 | v = v[:60] + " ...\n... " + v[-60:] 25 | print(" %s = %s" % (k,v)) 26 | -------------------------------------------------------------------------------- /dist/numpy/__config__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/__config__.pyc -------------------------------------------------------------------------------- /dist/numpy/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/_globals.py: -------------------------------------------------------------------------------- 1 | """ 2 | Module defining global singleton classes. 3 | 4 | This module raises a RuntimeError if an attempt to reload it is made. In that 5 | way the identities of the classes defined here are fixed and will remain so 6 | even if numpy itself is reloaded. In particular, a function like the following 7 | will still work correctly after numpy is reloaded:: 8 | 9 | def foo(arg=np._NoValue): 10 | if arg is np._NoValue: 11 | ... 12 | 13 | That was not the case when the singleton classes were defined in the numpy 14 | ``__init__.py`` file. See gh-7844 for a discussion of the reload problem that 15 | motivated this module. 16 | 17 | """ 18 | from __future__ import division, absolute_import, print_function 19 | 20 | 21 | __ALL__ = [ 22 | 'ModuleDeprecationWarning', 'VisibleDeprecationWarning', '_NoValue' 23 | ] 24 | 25 | 26 | # Disallow reloading this module so as to preserve the identities of the 27 | # classes defined here. 28 | if '_is_loaded' in globals(): 29 | raise RuntimeError('Reloading numpy._globals is not allowed') 30 | _is_loaded = True 31 | 32 | 33 | class ModuleDeprecationWarning(DeprecationWarning): 34 | """Module deprecation warning. 35 | 36 | The nose tester turns ordinary Deprecation warnings into test failures. 37 | That makes it hard to deprecate whole modules, because they get 38 | imported by default. So this is a special Deprecation warning that the 39 | nose tester will let pass without making tests fail. 40 | 41 | """ 42 | pass 43 | 44 | 45 | class VisibleDeprecationWarning(UserWarning): 46 | """Visible deprecation warning. 47 | 48 | By default, python will not show deprecation warnings, so this class 49 | can be used when a very visible warning is helpful, for example because 50 | the usage is most likely a user bug. 51 | 52 | """ 53 | pass 54 | 55 | 56 | class _NoValue: 57 | """Special keyword value. 58 | 59 | This class may be used as the default value assigned to a deprecated 60 | keyword in order to check if it has been given a user defined value. 61 | """ 62 | pass 63 | -------------------------------------------------------------------------------- /dist/numpy/_globals.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/_globals.pyc -------------------------------------------------------------------------------- /dist/numpy/_import_tools.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/_import_tools.pyc -------------------------------------------------------------------------------- /dist/numpy/add_newdocs.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/add_newdocs.pyc -------------------------------------------------------------------------------- /dist/numpy/compat/__init__.py: -------------------------------------------------------------------------------- 1 | """ 2 | Compatibility module. 3 | 4 | This module contains duplicated code from Python itself or 3rd party 5 | extensions, which may be included for the following reasons: 6 | 7 | * compatibility 8 | * we may only need a small subset of the copied library/module 9 | 10 | """ 11 | from __future__ import division, absolute_import, print_function 12 | 13 | from . import _inspect 14 | from . import py3k 15 | from ._inspect import getargspec, formatargspec 16 | from .py3k import * 17 | 18 | __all__ = [] 19 | __all__.extend(_inspect.__all__) 20 | __all__.extend(py3k.__all__) 21 | -------------------------------------------------------------------------------- /dist/numpy/compat/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/compat/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/compat/_inspect.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/compat/_inspect.pyc -------------------------------------------------------------------------------- /dist/numpy/compat/py3k.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/compat/py3k.pyc -------------------------------------------------------------------------------- /dist/numpy/compat/setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | from __future__ import division, print_function 3 | 4 | 5 | def configuration(parent_package='',top_path=None): 6 | from numpy.distutils.misc_util import Configuration 7 | config = Configuration('compat', parent_package, top_path) 8 | return config 9 | 10 | if __name__ == '__main__': 11 | from numpy.distutils.core import setup 12 | setup(configuration=configuration) 13 | -------------------------------------------------------------------------------- /dist/numpy/compat/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/compat/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/core/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/core/_internal.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/_internal.pyc -------------------------------------------------------------------------------- /dist/numpy/core/_methods.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/_methods.pyc -------------------------------------------------------------------------------- /dist/numpy/core/arrayprint.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/arrayprint.pyc -------------------------------------------------------------------------------- /dist/numpy/core/cversions.py: -------------------------------------------------------------------------------- 1 | """Simple script to compute the api hash of the current API. 2 | 3 | The API has is defined by numpy_api_order and ufunc_api_order. 4 | 5 | """ 6 | from __future__ import division, absolute_import, print_function 7 | 8 | from os.path import dirname 9 | 10 | from code_generators.genapi import fullapi_hash 11 | from code_generators.numpy_api import full_api 12 | 13 | if __name__ == '__main__': 14 | curdir = dirname(__file__) 15 | print(fullapi_hash(full_api)) 16 | -------------------------------------------------------------------------------- /dist/numpy/core/cversions.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/cversions.pyc -------------------------------------------------------------------------------- /dist/numpy/core/defchararray.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/defchararray.pyc -------------------------------------------------------------------------------- /dist/numpy/core/fromnumeric.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/fromnumeric.pyc -------------------------------------------------------------------------------- /dist/numpy/core/function_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/function_base.pyc -------------------------------------------------------------------------------- /dist/numpy/core/generate_numpy_api.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/generate_numpy_api.pyc -------------------------------------------------------------------------------- /dist/numpy/core/getlimits.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/getlimits.pyc -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/_neighborhood_iterator_imp.h: -------------------------------------------------------------------------------- 1 | #ifndef _NPY_INCLUDE_NEIGHBORHOOD_IMP 2 | #error You should not include this header directly 3 | #endif 4 | /* 5 | * Private API (here for inline) 6 | */ 7 | static NPY_INLINE int 8 | _PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter); 9 | 10 | /* 11 | * Update to next item of the iterator 12 | * 13 | * Note: this simply increment the coordinates vector, last dimension 14 | * incremented first , i.e, for dimension 3 15 | * ... 16 | * -1, -1, -1 17 | * -1, -1, 0 18 | * -1, -1, 1 19 | * .... 20 | * -1, 0, -1 21 | * -1, 0, 0 22 | * .... 23 | * 0, -1, -1 24 | * 0, -1, 0 25 | * .... 26 | */ 27 | #define _UPDATE_COORD_ITER(c) \ 28 | wb = iter->coordinates[c] < iter->bounds[c][1]; \ 29 | if (wb) { \ 30 | iter->coordinates[c] += 1; \ 31 | return 0; \ 32 | } \ 33 | else { \ 34 | iter->coordinates[c] = iter->bounds[c][0]; \ 35 | } 36 | 37 | static NPY_INLINE int 38 | _PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter) 39 | { 40 | npy_intp i, wb; 41 | 42 | for (i = iter->nd - 1; i >= 0; --i) { 43 | _UPDATE_COORD_ITER(i) 44 | } 45 | 46 | return 0; 47 | } 48 | 49 | /* 50 | * Version optimized for 2d arrays, manual loop unrolling 51 | */ 52 | static NPY_INLINE int 53 | _PyArrayNeighborhoodIter_IncrCoord2D(PyArrayNeighborhoodIterObject* iter) 54 | { 55 | npy_intp wb; 56 | 57 | _UPDATE_COORD_ITER(1) 58 | _UPDATE_COORD_ITER(0) 59 | 60 | return 0; 61 | } 62 | #undef _UPDATE_COORD_ITER 63 | 64 | /* 65 | * Advance to the next neighbour 66 | */ 67 | static NPY_INLINE int 68 | PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter) 69 | { 70 | _PyArrayNeighborhoodIter_IncrCoord (iter); 71 | iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates); 72 | 73 | return 0; 74 | } 75 | 76 | /* 77 | * Reset functions 78 | */ 79 | static NPY_INLINE int 80 | PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter) 81 | { 82 | npy_intp i; 83 | 84 | for (i = 0; i < iter->nd; ++i) { 85 | iter->coordinates[i] = iter->bounds[i][0]; 86 | } 87 | iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates); 88 | 89 | return 0; 90 | } 91 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/_numpyconfig.h: -------------------------------------------------------------------------------- 1 | #define NPY_HAVE_ENDIAN_H 1 2 | #define NPY_SIZEOF_SHORT SIZEOF_SHORT 3 | #define NPY_SIZEOF_INT SIZEOF_INT 4 | #define NPY_SIZEOF_LONG SIZEOF_LONG 5 | #define NPY_SIZEOF_FLOAT 4 6 | #define NPY_SIZEOF_COMPLEX_FLOAT 8 7 | #define NPY_SIZEOF_DOUBLE 8 8 | #define NPY_SIZEOF_COMPLEX_DOUBLE 16 9 | #define NPY_SIZEOF_LONGDOUBLE 16 10 | #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32 11 | #define NPY_SIZEOF_PY_INTPTR_T 8 12 | #define NPY_SIZEOF_OFF_T 8 13 | #define NPY_SIZEOF_PY_LONG_LONG 8 14 | #define NPY_SIZEOF_LONGLONG 8 15 | #define NPY_NO_SMP 0 16 | #define NPY_HAVE_DECL_ISNAN 17 | #define NPY_HAVE_DECL_ISINF 18 | #define NPY_HAVE_DECL_ISFINITE 19 | #define NPY_HAVE_DECL_SIGNBIT 20 | #define NPY_USE_C99_COMPLEX 1 21 | #define NPY_HAVE_COMPLEX_DOUBLE 1 22 | #define NPY_HAVE_COMPLEX_FLOAT 1 23 | #define NPY_HAVE_COMPLEX_LONG_DOUBLE 1 24 | #define NPY_USE_C99_FORMATS 1 25 | #define NPY_VISIBILITY_HIDDEN __attribute__((visibility("hidden"))) 26 | #define NPY_ABI_VERSION 0x01000009 27 | #define NPY_API_VERSION 0x0000000A 28 | 29 | #ifndef __STDC_FORMAT_MACROS 30 | #define __STDC_FORMAT_MACROS 1 31 | #endif 32 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/arrayobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ARRAYOBJECT_H 2 | #define Py_ARRAYOBJECT_H 3 | 4 | #include "ndarrayobject.h" 5 | #include "npy_interrupt.h" 6 | 7 | #ifdef NPY_NO_PREFIX 8 | #include "noprefix.h" 9 | #endif 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/halffloat.h: -------------------------------------------------------------------------------- 1 | #ifndef __NPY_HALFFLOAT_H__ 2 | #define __NPY_HALFFLOAT_H__ 3 | 4 | #include 5 | #include 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | /* 12 | * Half-precision routines 13 | */ 14 | 15 | /* Conversions */ 16 | float npy_half_to_float(npy_half h); 17 | double npy_half_to_double(npy_half h); 18 | npy_half npy_float_to_half(float f); 19 | npy_half npy_double_to_half(double d); 20 | /* Comparisons */ 21 | int npy_half_eq(npy_half h1, npy_half h2); 22 | int npy_half_ne(npy_half h1, npy_half h2); 23 | int npy_half_le(npy_half h1, npy_half h2); 24 | int npy_half_lt(npy_half h1, npy_half h2); 25 | int npy_half_ge(npy_half h1, npy_half h2); 26 | int npy_half_gt(npy_half h1, npy_half h2); 27 | /* faster *_nonan variants for when you know h1 and h2 are not NaN */ 28 | int npy_half_eq_nonan(npy_half h1, npy_half h2); 29 | int npy_half_lt_nonan(npy_half h1, npy_half h2); 30 | int npy_half_le_nonan(npy_half h1, npy_half h2); 31 | /* Miscellaneous functions */ 32 | int npy_half_iszero(npy_half h); 33 | int npy_half_isnan(npy_half h); 34 | int npy_half_isinf(npy_half h); 35 | int npy_half_isfinite(npy_half h); 36 | int npy_half_signbit(npy_half h); 37 | npy_half npy_half_copysign(npy_half x, npy_half y); 38 | npy_half npy_half_spacing(npy_half h); 39 | npy_half npy_half_nextafter(npy_half x, npy_half y); 40 | npy_half npy_half_divmod(npy_half x, npy_half y, npy_half *modulus); 41 | 42 | /* 43 | * Half-precision constants 44 | */ 45 | 46 | #define NPY_HALF_ZERO (0x0000u) 47 | #define NPY_HALF_PZERO (0x0000u) 48 | #define NPY_HALF_NZERO (0x8000u) 49 | #define NPY_HALF_ONE (0x3c00u) 50 | #define NPY_HALF_NEGONE (0xbc00u) 51 | #define NPY_HALF_PINF (0x7c00u) 52 | #define NPY_HALF_NINF (0xfc00u) 53 | #define NPY_HALF_NAN (0x7e00u) 54 | 55 | #define NPY_MAX_HALF (0x7bffu) 56 | 57 | /* 58 | * Bit-level conversions 59 | */ 60 | 61 | npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f); 62 | npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d); 63 | npy_uint32 npy_halfbits_to_floatbits(npy_uint16 h); 64 | npy_uint64 npy_halfbits_to_doublebits(npy_uint16 h); 65 | 66 | #ifdef __cplusplus 67 | } 68 | #endif 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/npy_endian.h: -------------------------------------------------------------------------------- 1 | #ifndef _NPY_ENDIAN_H_ 2 | #define _NPY_ENDIAN_H_ 3 | 4 | /* 5 | * NPY_BYTE_ORDER is set to the same value as BYTE_ORDER set by glibc in 6 | * endian.h 7 | */ 8 | 9 | #ifdef NPY_HAVE_ENDIAN_H 10 | /* Use endian.h if available */ 11 | #include 12 | 13 | #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && defined(LITTLE_ENDIAN) 14 | #define NPY_BYTE_ORDER BYTE_ORDER 15 | #define NPY_LITTLE_ENDIAN LITTLE_ENDIAN 16 | #define NPY_BIG_ENDIAN BIG_ENDIAN 17 | #elif defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && defined(_LITTLE_ENDIAN) 18 | #define NPY_BYTE_ORDER _BYTE_ORDER 19 | #define NPY_LITTLE_ENDIAN _LITTLE_ENDIAN 20 | #define NPY_BIG_ENDIAN _BIG_ENDIAN 21 | #elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && defined(__LITTLE_ENDIAN) 22 | #define NPY_BYTE_ORDER __BYTE_ORDER 23 | #define NPY_LITTLE_ENDIAN __LITTLE_ENDIAN 24 | #define NPY_BIG_ENDIAN __BIG_ENDIAN 25 | #endif 26 | #endif 27 | 28 | #ifndef NPY_BYTE_ORDER 29 | /* Set endianness info using target CPU */ 30 | #include "npy_cpu.h" 31 | 32 | #define NPY_LITTLE_ENDIAN 1234 33 | #define NPY_BIG_ENDIAN 4321 34 | 35 | #if defined(NPY_CPU_X86) \ 36 | || defined(NPY_CPU_AMD64) \ 37 | || defined(NPY_CPU_IA64) \ 38 | || defined(NPY_CPU_ALPHA) \ 39 | || defined(NPY_CPU_ARMEL) \ 40 | || defined(NPY_CPU_AARCH64) \ 41 | || defined(NPY_CPU_SH_LE) \ 42 | || defined(NPY_CPU_MIPSEL) \ 43 | || defined(NPY_CPU_PPC64LE) 44 | #define NPY_BYTE_ORDER NPY_LITTLE_ENDIAN 45 | #elif defined(NPY_CPU_PPC) \ 46 | || defined(NPY_CPU_SPARC) \ 47 | || defined(NPY_CPU_S390) \ 48 | || defined(NPY_CPU_HPPA) \ 49 | || defined(NPY_CPU_PPC64) \ 50 | || defined(NPY_CPU_ARMEB) \ 51 | || defined(NPY_CPU_SH_BE) \ 52 | || defined(NPY_CPU_MIPSEB) \ 53 | || defined(NPY_CPU_OR1K) \ 54 | || defined(NPY_CPU_M68K) 55 | #define NPY_BYTE_ORDER NPY_BIG_ENDIAN 56 | #else 57 | #error Unknown CPU: can not set endianness 58 | #endif 59 | #endif 60 | 61 | #endif 62 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/npy_no_deprecated_api.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This include file is provided for inclusion in Cython *.pyd files where 3 | * one would like to define the NPY_NO_DEPRECATED_API macro. It can be 4 | * included by 5 | * 6 | * cdef extern from "npy_no_deprecated_api.h": pass 7 | * 8 | */ 9 | #ifndef NPY_NO_DEPRECATED_API 10 | 11 | /* put this check here since there may be multiple includes in C extensions. */ 12 | #if defined(NDARRAYTYPES_H) || defined(_NPY_DEPRECATED_API_H) || \ 13 | defined(OLD_DEFINES_H) 14 | #error "npy_no_deprecated_api.h" must be first among numpy includes. 15 | #else 16 | #define NPY_NO_DEPRECATED_API NPY_API_VERSION 17 | #endif 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/npy_os.h: -------------------------------------------------------------------------------- 1 | #ifndef _NPY_OS_H_ 2 | #define _NPY_OS_H_ 3 | 4 | #if defined(linux) || defined(__linux) || defined(__linux__) 5 | #define NPY_OS_LINUX 6 | #elif defined(__FreeBSD__) || defined(__NetBSD__) || \ 7 | defined(__OpenBSD__) || defined(__DragonFly__) 8 | #define NPY_OS_BSD 9 | #ifdef __FreeBSD__ 10 | #define NPY_OS_FREEBSD 11 | #elif defined(__NetBSD__) 12 | #define NPY_OS_NETBSD 13 | #elif defined(__OpenBSD__) 14 | #define NPY_OS_OPENBSD 15 | #elif defined(__DragonFly__) 16 | #define NPY_OS_DRAGONFLY 17 | #endif 18 | #elif defined(sun) || defined(__sun) 19 | #define NPY_OS_SOLARIS 20 | #elif defined(__CYGWIN__) 21 | #define NPY_OS_CYGWIN 22 | #elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) 23 | #define NPY_OS_WIN32 24 | #elif defined(__APPLE__) 25 | #define NPY_OS_DARWIN 26 | #else 27 | #define NPY_OS_UNKNOWN 28 | #endif 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/numpyconfig.h: -------------------------------------------------------------------------------- 1 | #ifndef _NPY_NUMPYCONFIG_H_ 2 | #define _NPY_NUMPYCONFIG_H_ 3 | 4 | #include "_numpyconfig.h" 5 | 6 | /* 7 | * On Mac OS X, because there is only one configuration stage for all the archs 8 | * in universal builds, any macro which depends on the arch needs to be 9 | * harcoded 10 | */ 11 | #ifdef __APPLE__ 12 | #undef NPY_SIZEOF_LONG 13 | #undef NPY_SIZEOF_PY_INTPTR_T 14 | 15 | #ifdef __LP64__ 16 | #define NPY_SIZEOF_LONG 8 17 | #define NPY_SIZEOF_PY_INTPTR_T 8 18 | #else 19 | #define NPY_SIZEOF_LONG 4 20 | #define NPY_SIZEOF_PY_INTPTR_T 4 21 | #endif 22 | #endif 23 | 24 | /** 25 | * To help with the NPY_NO_DEPRECATED_API macro, we include API version 26 | * numbers for specific versions of NumPy. To exclude all API that was 27 | * deprecated as of 1.7, add the following before #including any NumPy 28 | * headers: 29 | * #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 30 | */ 31 | #define NPY_1_7_API_VERSION 0x00000007 32 | #define NPY_1_8_API_VERSION 0x00000008 33 | #define NPY_1_9_API_VERSION 0x00000008 34 | #define NPY_1_10_API_VERSION 0x00000008 35 | #define NPY_1_11_API_VERSION 0x00000008 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/oldnumeric.h: -------------------------------------------------------------------------------- 1 | #include "arrayobject.h" 2 | 3 | #ifndef REFCOUNT 4 | # define REFCOUNT NPY_REFCOUNT 5 | # define MAX_ELSIZE 16 6 | #endif 7 | 8 | #define PyArray_UNSIGNED_TYPES 9 | #define PyArray_SBYTE NPY_BYTE 10 | #define PyArray_CopyArray PyArray_CopyInto 11 | #define _PyArray_multiply_list PyArray_MultiplyIntList 12 | #define PyArray_ISSPACESAVER(m) NPY_FALSE 13 | #define PyScalarArray_Check PyArray_CheckScalar 14 | 15 | #define CONTIGUOUS NPY_CONTIGUOUS 16 | #define OWN_DIMENSIONS 0 17 | #define OWN_STRIDES 0 18 | #define OWN_DATA NPY_OWNDATA 19 | #define SAVESPACE 0 20 | #define SAVESPACEBIT 0 21 | 22 | #undef import_array 23 | #define import_array() { if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); } } 24 | -------------------------------------------------------------------------------- /dist/numpy/core/include/numpy/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef __NUMPY_UTILS_HEADER__ 2 | #define __NUMPY_UTILS_HEADER__ 3 | 4 | #ifndef __COMP_NPY_UNUSED 5 | #if defined(__GNUC__) 6 | #define __COMP_NPY_UNUSED __attribute__ ((__unused__)) 7 | # elif defined(__ICC) 8 | #define __COMP_NPY_UNUSED __attribute__ ((__unused__)) 9 | #else 10 | #define __COMP_NPY_UNUSED 11 | #endif 12 | #endif 13 | 14 | /* Use this to tag a variable as not used. It will remove unused variable 15 | * warning on support platforms (see __COM_NPY_UNUSED) and mangle the variable 16 | * to avoid accidental use */ 17 | #define NPY_UNUSED(x) (__NPY_UNUSED_TAGGED ## x) __COMP_NPY_UNUSED 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /dist/numpy/core/info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/info.pyc -------------------------------------------------------------------------------- /dist/numpy/core/lib/libnpymath.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/lib/libnpymath.a -------------------------------------------------------------------------------- /dist/numpy/core/lib/npy-pkg-config/mlib.ini: -------------------------------------------------------------------------------- 1 | [meta] 2 | Name = mlib 3 | Description = Math library used with this version of numpy 4 | Version = 1.0 5 | 6 | [default] 7 | Libs=-lm 8 | Cflags= 9 | 10 | [msvc] 11 | Libs=m.lib 12 | Cflags= 13 | -------------------------------------------------------------------------------- /dist/numpy/core/lib/npy-pkg-config/npymath.ini: -------------------------------------------------------------------------------- 1 | [meta] 2 | Name=npymath 3 | Description=Portable, core math library implementing C99 standard 4 | Version=0.1 5 | 6 | [variables] 7 | pkgname=numpy.core 8 | prefix=${pkgdir} 9 | libdir=${prefix}/lib 10 | includedir=${prefix}/include 11 | 12 | [default] 13 | Libs=-L${libdir} -lnpymath 14 | Cflags=-I${includedir} 15 | Requires=mlib 16 | 17 | [msvc] 18 | Libs=/LIBPATH:${libdir} npymath.lib 19 | Cflags=/INCLUDE:${includedir} 20 | Requires=mlib 21 | -------------------------------------------------------------------------------- /dist/numpy/core/machar.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/machar.pyc -------------------------------------------------------------------------------- /dist/numpy/core/memmap.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/memmap.pyc -------------------------------------------------------------------------------- /dist/numpy/core/numeric.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/numeric.pyc -------------------------------------------------------------------------------- /dist/numpy/core/numerictypes.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/numerictypes.pyc -------------------------------------------------------------------------------- /dist/numpy/core/records.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/records.pyc -------------------------------------------------------------------------------- /dist/numpy/core/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/core/setup_common.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/setup_common.pyc -------------------------------------------------------------------------------- /dist/numpy/core/shape_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/shape_base.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/data/astype_copy.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/data/astype_copy.pkl -------------------------------------------------------------------------------- /dist/numpy/core/tests/data/recarray_from_file.fits: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/data/recarray_from_file.fits -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_abc.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from numpy.testing import TestCase, assert_, run_module_suite 4 | 5 | import numbers 6 | from numpy.core.numerictypes import sctypes 7 | 8 | class ABC(TestCase): 9 | def test_floats(self): 10 | for t in sctypes['float']: 11 | assert_(isinstance(t(), numbers.Real), 12 | "{0} is not instance of Real".format(t.__name__)) 13 | assert_(issubclass(t, numbers.Real), 14 | "{0} is not subclass of Real".format(t.__name__)) 15 | assert_(not isinstance(t(), numbers.Rational), 16 | "{0} is instance of Rational".format(t.__name__)) 17 | assert_(not issubclass(t, numbers.Rational), 18 | "{0} is subclass of Rational".format(t.__name__)) 19 | 20 | def test_complex(self): 21 | for t in sctypes['complex']: 22 | assert_(isinstance(t(), numbers.Complex), 23 | "{0} is not instance of Complex".format(t.__name__)) 24 | assert_(issubclass(t, numbers.Complex), 25 | "{0} is not subclass of Complex".format(t.__name__)) 26 | assert_(not isinstance(t(), numbers.Real), 27 | "{0} is instance of Real".format(t.__name__)) 28 | assert_(not issubclass(t, numbers.Real), 29 | "{0} is subclass of Real".format(t.__name__)) 30 | 31 | def test_int(self): 32 | for t in sctypes['int']: 33 | assert_(isinstance(t(), numbers.Integral), 34 | "{0} is not instance of Integral".format(t.__name__)) 35 | assert_(issubclass(t, numbers.Integral), 36 | "{0} is not subclass of Integral".format(t.__name__)) 37 | 38 | def test_uint(self): 39 | for t in sctypes['uint']: 40 | assert_(isinstance(t(), numbers.Integral), 41 | "{0} is not instance of Integral".format(t.__name__)) 42 | assert_(issubclass(t, numbers.Integral), 43 | "{0} is not subclass of Integral".format(t.__name__)) 44 | 45 | 46 | if __name__ == "__main__": 47 | run_module_suite() 48 | -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_abc.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_abc.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_api.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_api.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_arrayprint.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_arrayprint.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_datetime.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_datetime.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_defchararray.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_defchararray.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_deprecations.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_deprecations.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_dtype.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_dtype.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_einsum.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_einsum.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_errstate.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import platform 4 | 5 | import numpy as np 6 | from numpy.testing import TestCase, assert_, run_module_suite, dec 7 | 8 | 9 | class TestErrstate(TestCase): 10 | @dec.skipif(platform.machine() == "armv5tel", "See gh-413.") 11 | def test_invalid(self): 12 | with np.errstate(all='raise', under='ignore'): 13 | a = -np.arange(3) 14 | # This should work 15 | with np.errstate(invalid='ignore'): 16 | np.sqrt(a) 17 | # While this should fail! 18 | try: 19 | np.sqrt(a) 20 | except FloatingPointError: 21 | pass 22 | else: 23 | self.fail("Did not raise an invalid error") 24 | 25 | def test_divide(self): 26 | with np.errstate(all='raise', under='ignore'): 27 | a = -np.arange(3) 28 | # This should work 29 | with np.errstate(divide='ignore'): 30 | a // 0 31 | # While this should fail! 32 | try: 33 | a // 0 34 | except FloatingPointError: 35 | pass 36 | else: 37 | self.fail("Did not raise divide by zero error") 38 | 39 | def test_errcall(self): 40 | def foo(*args): 41 | print(args) 42 | 43 | olderrcall = np.geterrcall() 44 | with np.errstate(call=foo): 45 | assert_(np.geterrcall() is foo, 'call is not foo') 46 | with np.errstate(call=None): 47 | assert_(np.geterrcall() is None, 'call is not None') 48 | assert_(np.geterrcall() is olderrcall, 'call is not olderrcall') 49 | 50 | 51 | if __name__ == "__main__": 52 | run_module_suite() 53 | -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_errstate.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_errstate.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_extint128.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_extint128.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_function_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_function_base.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_getlimits.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_getlimits.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_half.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_half.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_indexerrors.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_indexerrors.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_indexing.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_indexing.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_item_selection.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_item_selection.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_longdouble.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_longdouble.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_machar.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from numpy.core.machar import MachAr 4 | import numpy.core.numerictypes as ntypes 5 | from numpy import errstate, array 6 | from numpy.testing import TestCase, run_module_suite 7 | 8 | class TestMachAr(TestCase): 9 | def _run_machar_highprec(self): 10 | # Instantiate MachAr instance with high enough precision to cause 11 | # underflow 12 | try: 13 | hiprec = ntypes.float96 14 | MachAr(lambda v:array([v], hiprec)) 15 | except AttributeError: 16 | "Skipping test: no ntypes.float96 available on this platform." 17 | 18 | def test_underlow(self): 19 | # Regression test for #759: 20 | # instanciating MachAr for dtype = np.float96 raises spurious warning. 21 | with errstate(all='raise'): 22 | try: 23 | self._run_machar_highprec() 24 | except FloatingPointError as e: 25 | self.fail("Caught %s exception, should not have been raised." % e) 26 | 27 | 28 | if __name__ == "__main__": 29 | run_module_suite() 30 | -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_machar.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_machar.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_mem_overlap.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_mem_overlap.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_memmap.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_memmap.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_multiarray.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_multiarray.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_nditer.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_nditer.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_numeric.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_numeric.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_numerictypes.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_numerictypes.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_print.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_print.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_records.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_records.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_regression.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_regression.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_scalarinherit.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ Test printing of scalar types. 3 | 4 | """ 5 | from __future__ import division, absolute_import, print_function 6 | 7 | import numpy as np 8 | from numpy.testing import TestCase, run_module_suite, assert_ 9 | 10 | 11 | class A(object): 12 | pass 13 | class B(A, np.float64): 14 | pass 15 | 16 | class C(B): 17 | pass 18 | class D(C, B): 19 | pass 20 | 21 | class B0(np.float64, A): 22 | pass 23 | class C0(B0): 24 | pass 25 | 26 | class TestInherit(TestCase): 27 | def test_init(self): 28 | x = B(1.0) 29 | assert_(str(x) == '1.0') 30 | y = C(2.0) 31 | assert_(str(y) == '2.0') 32 | z = D(3.0) 33 | assert_(str(z) == '3.0') 34 | 35 | def test_init2(self): 36 | x = B0(1.0) 37 | assert_(str(x) == '1.0') 38 | y = C0(2.0) 39 | assert_(str(y) == '2.0') 40 | 41 | if __name__ == "__main__": 42 | run_module_suite() 43 | -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_scalarinherit.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_scalarinherit.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_scalarmath.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_scalarmath.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_scalarprint.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ Test printing of scalar types. 3 | 4 | """ 5 | from __future__ import division, absolute_import, print_function 6 | 7 | import numpy as np 8 | from numpy.testing import TestCase, assert_, run_module_suite 9 | 10 | 11 | class TestRealScalars(TestCase): 12 | def test_str(self): 13 | svals = [0.0, -0.0, 1, -1, np.inf, -np.inf, np.nan] 14 | styps = [np.float16, np.float32, np.float64, np.longdouble] 15 | actual = [str(f(c)) for c in svals for f in styps] 16 | wanted = [ 17 | '0.0', '0.0', '0.0', '0.0', 18 | '-0.0', '-0.0', '-0.0', '-0.0', 19 | '1.0', '1.0', '1.0', '1.0', 20 | '-1.0', '-1.0', '-1.0', '-1.0', 21 | 'inf', 'inf', 'inf', 'inf', 22 | '-inf', '-inf', '-inf', '-inf', 23 | 'nan', 'nan', 'nan', 'nan'] 24 | 25 | for res, val in zip(actual, wanted): 26 | assert_(res == val) 27 | 28 | 29 | if __name__ == "__main__": 30 | run_module_suite() 31 | -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_scalarprint.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_scalarprint.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_shape_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_shape_base.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_ufunc.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_ufunc.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_umath.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_umath.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_umath_complex.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_umath_complex.pyc -------------------------------------------------------------------------------- /dist/numpy/core/tests/test_unicode.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/core/tests/test_unicode.pyc -------------------------------------------------------------------------------- /dist/numpy/ctypeslib.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ctypeslib.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/__config__.py: -------------------------------------------------------------------------------- 1 | # This file is generated by /tmp/pip-alns09-build/-c 2 | # It contains system_info results at the time of building this package. 3 | __all__ = ["get_info","show"] 4 | 5 | lapack_opt_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 6 | openblas_lapack_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 7 | blas_mkl_info={} 8 | openblas_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 9 | blas_opt_info={'libraries': ['openblas', 'openblas'], 'library_dirs': ['/usr/local/lib'], 'language': 'c', 'define_macros': [('HAVE_CBLAS', None)]} 10 | 11 | def get_info(name): 12 | g = globals() 13 | return g.get(name, g.get(name + "_info", {})) 14 | 15 | def show(): 16 | for name,info_dict in globals().items(): 17 | if name[0] == "_" or type(info_dict) is not type({}): continue 18 | print(name + ":") 19 | if not info_dict: 20 | print(" NOT AVAILABLE") 21 | for k,v in info_dict.items(): 22 | v = str(v) 23 | if k == "sources" and len(v) > 200: 24 | v = v[:60] + " ...\n... " + v[-60:] 25 | print(" %s = %s" % (k,v)) 26 | -------------------------------------------------------------------------------- /dist/numpy/distutils/__config__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/__config__.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/__init__.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | 5 | from .__version__ import version as __version__ 6 | # Must import local ccompiler ASAP in order to get 7 | # customized CCompiler.spawn effective. 8 | from . import ccompiler 9 | from . import unixccompiler 10 | 11 | from .info import __doc__ 12 | from .npy_pkg_config import * 13 | 14 | # If numpy is installed, add distutils.test() 15 | try: 16 | from . import __config__ 17 | # Normally numpy is installed if the above import works, but an interrupted 18 | # in-place build could also have left a __config__.py. In that case the 19 | # next import may still fail, so keep it inside the try block. 20 | from numpy.testing.nosetester import _numpy_tester 21 | test = _numpy_tester().test 22 | except ImportError: 23 | pass 24 | -------------------------------------------------------------------------------- /dist/numpy/distutils/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/__version__.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | major = 0 4 | minor = 4 5 | micro = 0 6 | version = '%(major)d.%(minor)d.%(micro)d' % (locals()) 7 | -------------------------------------------------------------------------------- /dist/numpy/distutils/__version__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/__version__.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/ccompiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/ccompiler.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/__init__.py: -------------------------------------------------------------------------------- 1 | """distutils.command 2 | 3 | Package containing implementation of all the standard Distutils 4 | commands. 5 | 6 | """ 7 | from __future__ import division, absolute_import, print_function 8 | 9 | def test_na_writable_attributes_deletion(): 10 | a = np.NA(2) 11 | attr = ['payload', 'dtype'] 12 | for s in attr: 13 | assert_raises(AttributeError, delattr, a, s) 14 | 15 | 16 | __revision__ = "$Id: __init__.py,v 1.3 2005/05/16 11:08:49 pearu Exp $" 17 | 18 | distutils_all = [ #'build_py', 19 | 'clean', 20 | 'install_clib', 21 | 'install_scripts', 22 | 'bdist', 23 | 'bdist_dumb', 24 | 'bdist_wininst', 25 | ] 26 | 27 | __import__('distutils.command', globals(), locals(), distutils_all) 28 | 29 | __all__ = ['build', 30 | 'config_compiler', 31 | 'config', 32 | 'build_src', 33 | 'build_py', 34 | 'build_ext', 35 | 'build_clib', 36 | 'build_scripts', 37 | 'install', 38 | 'install_data', 39 | 'install_headers', 40 | 'install_lib', 41 | 'bdist_rpm', 42 | 'sdist', 43 | ] + distutils_all 44 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/autodist.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/autodist.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/bdist_rpm.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | import sys 5 | if 'setuptools' in sys.modules: 6 | from setuptools.command.bdist_rpm import bdist_rpm as old_bdist_rpm 7 | else: 8 | from distutils.command.bdist_rpm import bdist_rpm as old_bdist_rpm 9 | 10 | class bdist_rpm(old_bdist_rpm): 11 | 12 | def _make_spec_file(self): 13 | spec_file = old_bdist_rpm._make_spec_file(self) 14 | 15 | # Replace hardcoded setup.py script name 16 | # with the real setup script name. 17 | setup_py = os.path.basename(sys.argv[0]) 18 | if setup_py == 'setup.py': 19 | return spec_file 20 | new_spec_file = [] 21 | for line in spec_file: 22 | line = line.replace('setup.py', setup_py) 23 | new_spec_file.append(line) 24 | return new_spec_file 25 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/bdist_rpm.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/bdist_rpm.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | import sys 5 | from distutils.command.build import build as old_build 6 | from distutils.util import get_platform 7 | from numpy.distutils.command.config_compiler import show_fortran_compilers 8 | 9 | class build(old_build): 10 | 11 | sub_commands = [('config_cc', lambda *args: True), 12 | ('config_fc', lambda *args: True), 13 | ('build_src', old_build.has_ext_modules), 14 | ] + old_build.sub_commands 15 | 16 | user_options = old_build.user_options + [ 17 | ('fcompiler=', None, 18 | "specify the Fortran compiler type"), 19 | ('parallel=', 'j', 20 | "number of parallel jobs"), 21 | ] 22 | 23 | help_options = old_build.help_options + [ 24 | ('help-fcompiler', None, "list available Fortran compilers", 25 | show_fortran_compilers), 26 | ] 27 | 28 | def initialize_options(self): 29 | old_build.initialize_options(self) 30 | self.fcompiler = None 31 | self.parallel = None 32 | 33 | def finalize_options(self): 34 | if self.parallel: 35 | try: 36 | self.parallel = int(self.parallel) 37 | except ValueError: 38 | raise ValueError("--parallel/-j argument must be an integer") 39 | build_scripts = self.build_scripts 40 | old_build.finalize_options(self) 41 | plat_specifier = ".%s-%s" % (get_platform(), sys.version[0:3]) 42 | if build_scripts is None: 43 | self.build_scripts = os.path.join(self.build_base, 44 | 'scripts' + plat_specifier) 45 | 46 | def run(self): 47 | old_build.run(self) 48 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/build.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build_clib.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/build_clib.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build_ext.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/build_ext.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build_py.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from distutils.command.build_py import build_py as old_build_py 4 | from numpy.distutils.misc_util import is_string 5 | 6 | class build_py(old_build_py): 7 | 8 | def run(self): 9 | build_src = self.get_finalized_command('build_src') 10 | if build_src.py_modules_dict and self.packages is None: 11 | self.packages = list(build_src.py_modules_dict.keys ()) 12 | old_build_py.run(self) 13 | 14 | def find_package_modules(self, package, package_dir): 15 | modules = old_build_py.find_package_modules(self, package, package_dir) 16 | 17 | # Find build_src generated *.py files. 18 | build_src = self.get_finalized_command('build_src') 19 | modules += build_src.py_modules_dict.get(package, []) 20 | 21 | return modules 22 | 23 | def find_modules(self): 24 | old_py_modules = self.py_modules[:] 25 | new_py_modules = [_m for _m in self.py_modules if is_string(_m)] 26 | self.py_modules[:] = new_py_modules 27 | modules = old_build_py.find_modules(self) 28 | self.py_modules[:] = old_py_modules 29 | 30 | return modules 31 | 32 | # XXX: Fix find_source_files for item in py_modules such that item is 3-tuple 33 | # and item[2] is source file. 34 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build_py.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/build_py.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build_scripts.py: -------------------------------------------------------------------------------- 1 | """ Modified version of build_scripts that handles building scripts from functions. 2 | 3 | """ 4 | from __future__ import division, absolute_import, print_function 5 | 6 | from distutils.command.build_scripts import build_scripts as old_build_scripts 7 | from numpy.distutils import log 8 | from numpy.distutils.misc_util import is_string 9 | 10 | class build_scripts(old_build_scripts): 11 | 12 | def generate_scripts(self, scripts): 13 | new_scripts = [] 14 | func_scripts = [] 15 | for script in scripts: 16 | if is_string(script): 17 | new_scripts.append(script) 18 | else: 19 | func_scripts.append(script) 20 | if not func_scripts: 21 | return new_scripts 22 | 23 | build_dir = self.build_dir 24 | self.mkpath(build_dir) 25 | for func in func_scripts: 26 | script = func(build_dir) 27 | if not script: 28 | continue 29 | if is_string(script): 30 | log.info(" adding '%s' to scripts" % (script,)) 31 | new_scripts.append(script) 32 | else: 33 | [log.info(" adding '%s' to scripts" % (s,)) for s in script] 34 | new_scripts.extend(list(script)) 35 | return new_scripts 36 | 37 | def run (self): 38 | if not self.scripts: 39 | return 40 | 41 | self.scripts = self.generate_scripts(self.scripts) 42 | # Now make sure that the distribution object has this list of scripts. 43 | # setuptools' develop command requires that this be a list of filenames, 44 | # not functions. 45 | self.distribution.scripts = self.scripts 46 | 47 | return old_build_scripts.run(self) 48 | 49 | def get_source_files(self): 50 | from numpy.distutils.misc_util import get_script_files 51 | return get_script_files(self.scripts) 52 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build_scripts.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/build_scripts.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/build_src.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/build_src.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/config.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/config.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/config_compiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/config_compiler.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/develop.py: -------------------------------------------------------------------------------- 1 | """ Override the develop command from setuptools so we can ensure that our 2 | generated files (from build_src or build_scripts) are properly converted to real 3 | files with filenames. 4 | 5 | """ 6 | from __future__ import division, absolute_import, print_function 7 | 8 | from setuptools.command.develop import develop as old_develop 9 | 10 | class develop(old_develop): 11 | __doc__ = old_develop.__doc__ 12 | def install_for_development(self): 13 | # Build sources in-place, too. 14 | self.reinitialize_command('build_src', inplace=1) 15 | # Make sure scripts are built. 16 | self.run_command('build_scripts') 17 | old_develop.install_for_development(self) 18 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/develop.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/develop.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/egg_info.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | 5 | from setuptools.command.egg_info import egg_info as _egg_info 6 | 7 | class egg_info(_egg_info): 8 | def run(self): 9 | if 'sdist' in sys.argv: 10 | import warnings 11 | warnings.warn("`build_src` is being run, this may lead to missing " 12 | "files in your sdist! See numpy issue gh-7127 for " 13 | "details", UserWarning) 14 | 15 | # We need to ensure that build_src has been executed in order to give 16 | # setuptools' egg_info command real filenames instead of functions which 17 | # generate files. 18 | self.run_command("build_src") 19 | _egg_info.run(self) 20 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/egg_info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/egg_info.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/install.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/install.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/install_clib.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | from distutils.core import Command 5 | from distutils.ccompiler import new_compiler 6 | from numpy.distutils.misc_util import get_cmd 7 | 8 | class install_clib(Command): 9 | description = "Command to install installable C libraries" 10 | 11 | user_options = [] 12 | 13 | def initialize_options(self): 14 | self.install_dir = None 15 | self.outfiles = [] 16 | 17 | def finalize_options(self): 18 | self.set_undefined_options('install', ('install_lib', 'install_dir')) 19 | 20 | def run (self): 21 | build_clib_cmd = get_cmd("build_clib") 22 | build_dir = build_clib_cmd.build_clib 23 | 24 | # We need the compiler to get the library name -> filename association 25 | if not build_clib_cmd.compiler: 26 | compiler = new_compiler(compiler=None) 27 | compiler.customize(self.distribution) 28 | else: 29 | compiler = build_clib_cmd.compiler 30 | 31 | for l in self.distribution.installed_libraries: 32 | target_dir = os.path.join(self.install_dir, l.target_dir) 33 | name = compiler.library_filename(l.name) 34 | source = os.path.join(build_dir, name) 35 | self.mkpath(target_dir) 36 | self.outfiles.append(self.copy_file(source, target_dir)[0]) 37 | 38 | def get_outputs(self): 39 | return self.outfiles 40 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/install_clib.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/install_clib.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/install_data.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | have_setuptools = ('setuptools' in sys.modules) 5 | 6 | from distutils.command.install_data import install_data as old_install_data 7 | 8 | #data installer with improved intelligence over distutils 9 | #data files are copied into the project directory instead 10 | #of willy-nilly 11 | class install_data (old_install_data): 12 | 13 | def run(self): 14 | old_install_data.run(self) 15 | 16 | if have_setuptools: 17 | # Run install_clib again, since setuptools does not run sub-commands 18 | # of install automatically 19 | self.run_command('install_clib') 20 | 21 | def finalize_options (self): 22 | self.set_undefined_options('install', 23 | ('install_lib', 'install_dir'), 24 | ('root', 'root'), 25 | ('force', 'force'), 26 | ) 27 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/install_data.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/install_data.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/install_headers.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | from distutils.command.install_headers import install_headers as old_install_headers 5 | 6 | class install_headers (old_install_headers): 7 | 8 | def run (self): 9 | headers = self.distribution.headers 10 | if not headers: 11 | return 12 | 13 | prefix = os.path.dirname(self.install_dir) 14 | for header in headers: 15 | if isinstance(header, tuple): 16 | # Kind of a hack, but I don't know where else to change this... 17 | if header[0] == 'numpy.core': 18 | header = ('numpy', header[1]) 19 | if os.path.splitext(header[1])[1] == '.inc': 20 | continue 21 | d = os.path.join(*([prefix]+header[0].split('.'))) 22 | header = header[1] 23 | else: 24 | d = self.install_dir 25 | self.mkpath(d) 26 | (out, _) = self.copy_file(header, d) 27 | self.outfiles.append(out) 28 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/install_headers.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/install_headers.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/command/sdist.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | if 'setuptools' in sys.modules: 5 | from setuptools.command.sdist import sdist as old_sdist 6 | else: 7 | from distutils.command.sdist import sdist as old_sdist 8 | 9 | from numpy.distutils.misc_util import get_data_files 10 | 11 | class sdist(old_sdist): 12 | 13 | def add_defaults (self): 14 | old_sdist.add_defaults(self) 15 | 16 | dist = self.distribution 17 | 18 | if dist.has_data_files(): 19 | for data in dist.data_files: 20 | self.filelist.extend(get_data_files(data)) 21 | 22 | if dist.has_headers(): 23 | headers = [] 24 | for h in dist.headers: 25 | if isinstance(h, str): headers.append(h) 26 | else: headers.append(h[1]) 27 | self.filelist.extend(headers) 28 | 29 | return 30 | -------------------------------------------------------------------------------- /dist/numpy/distutils/command/sdist.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/command/sdist.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/compat.py: -------------------------------------------------------------------------------- 1 | """Small modules to cope with python 2 vs 3 incompatibilities inside 2 | numpy.distutils 3 | 4 | """ 5 | from __future__ import division, absolute_import, print_function 6 | 7 | import sys 8 | 9 | def get_exception(): 10 | return sys.exc_info()[1] 11 | -------------------------------------------------------------------------------- /dist/numpy/distutils/compat.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/compat.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/conv_template.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/conv_template.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/core.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/core.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/cpuinfo.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/cpuinfo.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/environment.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/environment.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/exec_command.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/exec_command.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/extension.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/extension.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/absoft.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/absoft.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/compaq.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/compaq.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/g95.py: -------------------------------------------------------------------------------- 1 | # http://g95.sourceforge.net/ 2 | from __future__ import division, absolute_import, print_function 3 | 4 | from numpy.distutils.fcompiler import FCompiler 5 | 6 | compilers = ['G95FCompiler'] 7 | 8 | class G95FCompiler(FCompiler): 9 | compiler_type = 'g95' 10 | description = 'G95 Fortran Compiler' 11 | 12 | # version_pattern = r'G95 \((GCC (?P[\d.]+)|.*?) \(g95!\) (?P.*)\).*' 13 | # $ g95 --version 14 | # G95 (GCC 4.0.3 (g95!) May 22 2006) 15 | 16 | version_pattern = r'G95 \((GCC (?P[\d.]+)|.*?) \(g95 (?P.*)!\) (?P.*)\).*' 17 | # $ g95 --version 18 | # G95 (GCC 4.0.3 (g95 0.90!) Aug 22 2006) 19 | 20 | executables = { 21 | 'version_cmd' : ["", "--version"], 22 | 'compiler_f77' : ["g95", "-ffixed-form"], 23 | 'compiler_fix' : ["g95", "-ffixed-form"], 24 | 'compiler_f90' : ["g95"], 25 | 'linker_so' : ["", "-shared"], 26 | 'archiver' : ["ar", "-cr"], 27 | 'ranlib' : ["ranlib"] 28 | } 29 | pic_flags = ['-fpic'] 30 | module_dir_switch = '-fmod=' 31 | module_include_switch = '-I' 32 | 33 | def get_flags(self): 34 | return ['-fno-second-underscore'] 35 | def get_flags_opt(self): 36 | return ['-O'] 37 | def get_flags_debug(self): 38 | return ['-g'] 39 | 40 | if __name__ == '__main__': 41 | from distutils import log 42 | log.set_verbosity(2) 43 | compiler = G95FCompiler() 44 | compiler.customize() 45 | print(compiler.get_version()) 46 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/g95.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/g95.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/gnu.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/gnu.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/hpux.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from numpy.distutils.fcompiler import FCompiler 4 | 5 | compilers = ['HPUXFCompiler'] 6 | 7 | class HPUXFCompiler(FCompiler): 8 | 9 | compiler_type = 'hpux' 10 | description = 'HP Fortran 90 Compiler' 11 | version_pattern = r'HP F90 (?P[^\s*,]*)' 12 | 13 | executables = { 14 | 'version_cmd' : ["f90", "+version"], 15 | 'compiler_f77' : ["f90"], 16 | 'compiler_fix' : ["f90"], 17 | 'compiler_f90' : ["f90"], 18 | 'linker_so' : ["ld", "-b"], 19 | 'archiver' : ["ar", "-cr"], 20 | 'ranlib' : ["ranlib"] 21 | } 22 | module_dir_switch = None #XXX: fix me 23 | module_include_switch = None #XXX: fix me 24 | pic_flags = ['+Z'] 25 | def get_flags(self): 26 | return self.pic_flags + ['+ppu', '+DD64'] 27 | def get_flags_opt(self): 28 | return ['-O3'] 29 | def get_libraries(self): 30 | return ['m'] 31 | def get_library_dirs(self): 32 | opt = ['/usr/lib/hpux64'] 33 | return opt 34 | def get_version(self, force=0, ok_status=[256, 0, 1]): 35 | # XXX status==256 may indicate 'unrecognized option' or 36 | # 'no input file'. So, version_cmd needs more work. 37 | return FCompiler.get_version(self, force, ok_status) 38 | 39 | if __name__ == '__main__': 40 | from distutils import log 41 | log.set_verbosity(10) 42 | from numpy.distutils.fcompiler import new_fcompiler 43 | compiler = new_fcompiler(compiler='hpux') 44 | compiler.customize() 45 | print(compiler.get_version()) 46 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/hpux.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/hpux.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/ibm.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/ibm.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/intel.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/intel.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/lahey.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | 5 | from numpy.distutils.fcompiler import FCompiler 6 | 7 | compilers = ['LaheyFCompiler'] 8 | 9 | class LaheyFCompiler(FCompiler): 10 | 11 | compiler_type = 'lahey' 12 | description = 'Lahey/Fujitsu Fortran 95 Compiler' 13 | version_pattern = r'Lahey/Fujitsu Fortran 95 Compiler Release (?P[^\s*]*)' 14 | 15 | executables = { 16 | 'version_cmd' : ["", "--version"], 17 | 'compiler_f77' : ["lf95", "--fix"], 18 | 'compiler_fix' : ["lf95", "--fix"], 19 | 'compiler_f90' : ["lf95"], 20 | 'linker_so' : ["lf95", "-shared"], 21 | 'archiver' : ["ar", "-cr"], 22 | 'ranlib' : ["ranlib"] 23 | } 24 | 25 | module_dir_switch = None #XXX Fix me 26 | module_include_switch = None #XXX Fix me 27 | 28 | def get_flags_opt(self): 29 | return ['-O'] 30 | def get_flags_debug(self): 31 | return ['-g', '--chk', '--chkglobal'] 32 | def get_library_dirs(self): 33 | opt = [] 34 | d = os.environ.get('LAHEY') 35 | if d: 36 | opt.append(os.path.join(d, 'lib')) 37 | return opt 38 | def get_libraries(self): 39 | opt = [] 40 | opt.extend(['fj9f6', 'fj9i6', 'fj9ipp', 'fj9e6']) 41 | return opt 42 | 43 | if __name__ == '__main__': 44 | from distutils import log 45 | log.set_verbosity(2) 46 | from numpy.distutils.fcompiler import new_fcompiler 47 | compiler = new_fcompiler(compiler='lahey') 48 | compiler.customize() 49 | print(compiler.get_version()) 50 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/lahey.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/lahey.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/mips.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from numpy.distutils.cpuinfo import cpu 4 | from numpy.distutils.fcompiler import FCompiler 5 | 6 | compilers = ['MIPSFCompiler'] 7 | 8 | class MIPSFCompiler(FCompiler): 9 | 10 | compiler_type = 'mips' 11 | description = 'MIPSpro Fortran Compiler' 12 | version_pattern = r'MIPSpro Compilers: Version (?P[^\s*,]*)' 13 | 14 | executables = { 15 | 'version_cmd' : ["", "-version"], 16 | 'compiler_f77' : ["f77", "-f77"], 17 | 'compiler_fix' : ["f90", "-fixedform"], 18 | 'compiler_f90' : ["f90"], 19 | 'linker_so' : ["f90", "-shared"], 20 | 'archiver' : ["ar", "-cr"], 21 | 'ranlib' : None 22 | } 23 | module_dir_switch = None #XXX: fix me 24 | module_include_switch = None #XXX: fix me 25 | pic_flags = ['-KPIC'] 26 | 27 | def get_flags(self): 28 | return self.pic_flags + ['-n32'] 29 | def get_flags_opt(self): 30 | return ['-O3'] 31 | def get_flags_arch(self): 32 | opt = [] 33 | for a in '19 20 21 22_4k 22_5k 24 25 26 27 28 30 32_5k 32_10k'.split(): 34 | if getattr(cpu, 'is_IP%s'%a)(): 35 | opt.append('-TARG:platform=IP%s' % a) 36 | break 37 | return opt 38 | def get_flags_arch_f77(self): 39 | r = None 40 | if cpu.is_r10000(): r = 10000 41 | elif cpu.is_r12000(): r = 12000 42 | elif cpu.is_r8000(): r = 8000 43 | elif cpu.is_r5000(): r = 5000 44 | elif cpu.is_r4000(): r = 4000 45 | if r is not None: 46 | return ['r%s' % (r)] 47 | return [] 48 | def get_flags_arch_f90(self): 49 | r = self.get_flags_arch_f77() 50 | if r: 51 | r[0] = '-' + r[0] 52 | return r 53 | 54 | if __name__ == '__main__': 55 | from numpy.distutils.fcompiler import new_fcompiler 56 | compiler = new_fcompiler(compiler='mips') 57 | compiler.customize() 58 | print(compiler.get_version()) 59 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/mips.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/mips.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/nag.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | from numpy.distutils.fcompiler import FCompiler 5 | 6 | compilers = ['NAGFCompiler'] 7 | 8 | class NAGFCompiler(FCompiler): 9 | 10 | compiler_type = 'nag' 11 | description = 'NAGWare Fortran 95 Compiler' 12 | version_pattern = r'NAGWare Fortran 95 compiler Release (?P[^\s]*)' 13 | 14 | executables = { 15 | 'version_cmd' : ["", "-V"], 16 | 'compiler_f77' : ["f95", "-fixed"], 17 | 'compiler_fix' : ["f95", "-fixed"], 18 | 'compiler_f90' : ["f95"], 19 | 'linker_so' : [""], 20 | 'archiver' : ["ar", "-cr"], 21 | 'ranlib' : ["ranlib"] 22 | } 23 | 24 | def get_flags_linker_so(self): 25 | if sys.platform=='darwin': 26 | return ['-unsharedf95', '-Wl,-bundle,-flat_namespace,-undefined,suppress'] 27 | return ["-Wl,-shared"] 28 | def get_flags_opt(self): 29 | return ['-O4'] 30 | def get_flags_arch(self): 31 | version = self.get_version() 32 | if version and version < '5.1': 33 | return ['-target=native'] 34 | else: 35 | return [''] 36 | def get_flags_debug(self): 37 | return ['-g', '-gline', '-g90', '-nan', '-C'] 38 | 39 | if __name__ == '__main__': 40 | from distutils import log 41 | log.set_verbosity(2) 42 | from numpy.distutils.fcompiler import new_fcompiler 43 | compiler = new_fcompiler(compiler='nag') 44 | compiler.customize() 45 | print(compiler.get_version()) 46 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/nag.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/nag.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/none.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from numpy.distutils.fcompiler import FCompiler 4 | 5 | compilers = ['NoneFCompiler'] 6 | 7 | class NoneFCompiler(FCompiler): 8 | 9 | compiler_type = 'none' 10 | description = 'Fake Fortran compiler' 11 | 12 | executables = {'compiler_f77': None, 13 | 'compiler_f90': None, 14 | 'compiler_fix': None, 15 | 'linker_so': None, 16 | 'linker_exe': None, 17 | 'archiver': None, 18 | 'ranlib': None, 19 | 'version_cmd': None, 20 | } 21 | 22 | def find_executables(self): 23 | pass 24 | 25 | 26 | if __name__ == '__main__': 27 | from distutils import log 28 | log.set_verbosity(2) 29 | compiler = NoneFCompiler() 30 | compiler.customize() 31 | print(compiler.get_version()) 32 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/none.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/none.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/pathf95.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from numpy.distutils.fcompiler import FCompiler 4 | 5 | compilers = ['PathScaleFCompiler'] 6 | 7 | class PathScaleFCompiler(FCompiler): 8 | 9 | compiler_type = 'pathf95' 10 | description = 'PathScale Fortran Compiler' 11 | version_pattern = r'PathScale\(TM\) Compiler Suite: Version (?P[\d.]+)' 12 | 13 | executables = { 14 | 'version_cmd' : ["pathf95", "-version"], 15 | 'compiler_f77' : ["pathf95", "-fixedform"], 16 | 'compiler_fix' : ["pathf95", "-fixedform"], 17 | 'compiler_f90' : ["pathf95"], 18 | 'linker_so' : ["pathf95", "-shared"], 19 | 'archiver' : ["ar", "-cr"], 20 | 'ranlib' : ["ranlib"] 21 | } 22 | pic_flags = ['-fPIC'] 23 | module_dir_switch = '-module ' # Don't remove ending space! 24 | module_include_switch = '-I' 25 | 26 | def get_flags_opt(self): 27 | return ['-O3'] 28 | def get_flags_debug(self): 29 | return ['-g'] 30 | 31 | if __name__ == '__main__': 32 | from distutils import log 33 | log.set_verbosity(2) 34 | #compiler = PathScaleFCompiler() 35 | from numpy.distutils.fcompiler import new_fcompiler 36 | compiler = new_fcompiler(compiler='pathf95') 37 | compiler.customize() 38 | print(compiler.get_version()) 39 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/pathf95.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/pathf95.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/pg.py: -------------------------------------------------------------------------------- 1 | # http://www.pgroup.com 2 | from __future__ import division, absolute_import, print_function 3 | 4 | from numpy.distutils.fcompiler import FCompiler 5 | from sys import platform 6 | 7 | compilers = ['PGroupFCompiler'] 8 | 9 | class PGroupFCompiler(FCompiler): 10 | 11 | compiler_type = 'pg' 12 | description = 'Portland Group Fortran Compiler' 13 | version_pattern = r'\s*pg(f77|f90|hpf|fortran) (?P[\d.-]+).*' 14 | 15 | if platform == 'darwin': 16 | executables = { 17 | 'version_cmd' : ["", "-V"], 18 | 'compiler_f77' : ["pgfortran", "-dynamiclib"], 19 | 'compiler_fix' : ["pgfortran", "-Mfixed", "-dynamiclib"], 20 | 'compiler_f90' : ["pgfortran", "-dynamiclib"], 21 | 'linker_so' : ["libtool"], 22 | 'archiver' : ["ar", "-cr"], 23 | 'ranlib' : ["ranlib"] 24 | } 25 | pic_flags = [''] 26 | else: 27 | executables = { 28 | 'version_cmd' : ["", "-V"], 29 | 'compiler_f77' : ["pgfortran"], 30 | 'compiler_fix' : ["pgfortran", "-Mfixed"], 31 | 'compiler_f90' : ["pgfortran"], 32 | 'linker_so' : ["pgfortran", "-shared", "-fpic"], 33 | 'archiver' : ["ar", "-cr"], 34 | 'ranlib' : ["ranlib"] 35 | } 36 | pic_flags = ['-fpic'] 37 | 38 | 39 | module_dir_switch = '-module ' 40 | module_include_switch = '-I' 41 | 42 | def get_flags(self): 43 | opt = ['-Minform=inform', '-Mnosecond_underscore'] 44 | return self.pic_flags + opt 45 | def get_flags_opt(self): 46 | return ['-fast'] 47 | def get_flags_debug(self): 48 | return ['-g'] 49 | 50 | if platform == 'darwin': 51 | def get_flags_linker_so(self): 52 | return ["-dynamic", '-undefined', 'dynamic_lookup'] 53 | 54 | def runtime_library_dir_option(self, dir): 55 | return '-R"%s"' % dir 56 | 57 | if __name__ == '__main__': 58 | from distutils import log 59 | log.set_verbosity(2) 60 | from numpy.distutils.fcompiler import new_fcompiler 61 | compiler = new_fcompiler(compiler='pg') 62 | compiler.customize() 63 | print(compiler.get_version()) 64 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/pg.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/pg.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/sun.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from numpy.distutils.ccompiler import simple_version_match 4 | from numpy.distutils.fcompiler import FCompiler 5 | 6 | compilers = ['SunFCompiler'] 7 | 8 | class SunFCompiler(FCompiler): 9 | 10 | compiler_type = 'sun' 11 | description = 'Sun or Forte Fortran 95 Compiler' 12 | # ex: 13 | # f90: Sun WorkShop 6 update 2 Fortran 95 6.2 Patch 111690-10 2003/08/28 14 | version_match = simple_version_match( 15 | start=r'f9[05]: (Sun|Forte|WorkShop).*Fortran 95') 16 | 17 | executables = { 18 | 'version_cmd' : ["", "-V"], 19 | 'compiler_f77' : ["f90"], 20 | 'compiler_fix' : ["f90", "-fixed"], 21 | 'compiler_f90' : ["f90"], 22 | 'linker_so' : ["", "-Bdynamic", "-G"], 23 | 'archiver' : ["ar", "-cr"], 24 | 'ranlib' : ["ranlib"] 25 | } 26 | module_dir_switch = '-moddir=' 27 | module_include_switch = '-M' 28 | pic_flags = ['-xcode=pic32'] 29 | 30 | def get_flags_f77(self): 31 | ret = ["-ftrap=%none"] 32 | if (self.get_version() or '') >= '7': 33 | ret.append("-f77") 34 | else: 35 | ret.append("-fixed") 36 | return ret 37 | def get_opt(self): 38 | return ['-fast', '-dalign'] 39 | def get_arch(self): 40 | return ['-xtarget=generic'] 41 | def get_libraries(self): 42 | opt = [] 43 | opt.extend(['fsu', 'sunmath', 'mvec']) 44 | return opt 45 | 46 | def runtime_library_dir_option(self, dir): 47 | return '-R"%s"' % dir 48 | 49 | if __name__ == '__main__': 50 | from distutils import log 51 | log.set_verbosity(2) 52 | from numpy.distutils.fcompiler import new_fcompiler 53 | compiler = new_fcompiler(compiler='sun') 54 | compiler.customize() 55 | print(compiler.get_version()) 56 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/sun.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/sun.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/vast.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | 5 | from numpy.distutils.fcompiler.gnu import GnuFCompiler 6 | 7 | compilers = ['VastFCompiler'] 8 | 9 | class VastFCompiler(GnuFCompiler): 10 | compiler_type = 'vast' 11 | compiler_aliases = () 12 | description = 'Pacific-Sierra Research Fortran 90 Compiler' 13 | version_pattern = r'\s*Pacific-Sierra Research vf90 '\ 14 | '(Personal|Professional)\s+(?P[^\s]*)' 15 | 16 | # VAST f90 does not support -o with -c. So, object files are created 17 | # to the current directory and then moved to build directory 18 | object_switch = ' && function _mvfile { mv -v `basename $1` $1 ; } && _mvfile ' 19 | 20 | executables = { 21 | 'version_cmd' : ["vf90", "-v"], 22 | 'compiler_f77' : ["g77"], 23 | 'compiler_fix' : ["f90", "-Wv,-ya"], 24 | 'compiler_f90' : ["f90"], 25 | 'linker_so' : [""], 26 | 'archiver' : ["ar", "-cr"], 27 | 'ranlib' : ["ranlib"] 28 | } 29 | module_dir_switch = None #XXX Fix me 30 | module_include_switch = None #XXX Fix me 31 | 32 | def find_executables(self): 33 | pass 34 | 35 | def get_version_cmd(self): 36 | f90 = self.compiler_f90[0] 37 | d, b = os.path.split(f90) 38 | vf90 = os.path.join(d, 'v'+b) 39 | return vf90 40 | 41 | def get_flags_arch(self): 42 | vast_version = self.get_version() 43 | gnu = GnuFCompiler() 44 | gnu.customize(None) 45 | self.version = gnu.get_version() 46 | opt = GnuFCompiler.get_flags_arch(self) 47 | self.version = vast_version 48 | return opt 49 | 50 | if __name__ == '__main__': 51 | from distutils import log 52 | log.set_verbosity(2) 53 | from numpy.distutils.fcompiler import new_fcompiler 54 | compiler = new_fcompiler(compiler='vast') 55 | compiler.customize() 56 | print(compiler.get_version()) 57 | -------------------------------------------------------------------------------- /dist/numpy/distutils/fcompiler/vast.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/fcompiler/vast.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/from_template.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/from_template.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/info.py: -------------------------------------------------------------------------------- 1 | """ 2 | Enhanced distutils with Fortran compilers support and more. 3 | """ 4 | from __future__ import division, absolute_import, print_function 5 | 6 | postpone_import = True 7 | -------------------------------------------------------------------------------- /dist/numpy/distutils/info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/info.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/intelccompiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/intelccompiler.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/lib2def.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/lib2def.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/line_endings.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/line_endings.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/log.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/log.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/mingw/gfortran_vs2003_hack.c: -------------------------------------------------------------------------------- 1 | int _get_output_format(void) 2 | { 3 | return 0; 4 | } 5 | 6 | int _imp____lc_codepage = 0; 7 | -------------------------------------------------------------------------------- /dist/numpy/distutils/mingw32ccompiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/mingw32ccompiler.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/misc_util.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/misc_util.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/msvc9compiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/msvc9compiler.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/msvccompiler.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | from distutils.msvccompiler import MSVCCompiler as _MSVCCompiler 5 | 6 | from .system_info import platform_bits 7 | 8 | 9 | def _merge(old, new): 10 | """Concatenate two environment paths avoiding repeats. 11 | 12 | Here `old` is the environment string before the base class initialize 13 | function is called and `new` is the string after the call. The new string 14 | will be a fixed string if it is not obtained from the current enviroment, 15 | or the same as the old string if obtained from the same enviroment. The aim 16 | here is not to append the new string if it is already contained in the old 17 | string so as to limit the growth of the environment string. 18 | 19 | Parameters 20 | ---------- 21 | old : string 22 | Previous enviroment string. 23 | new : string 24 | New environment string. 25 | 26 | Returns 27 | ------- 28 | ret : string 29 | Updated environment string. 30 | 31 | """ 32 | if new in old: 33 | return old 34 | if not old: 35 | return new 36 | 37 | # Neither new nor old is empty. Give old priority. 38 | return ';'.join([old, new]) 39 | 40 | 41 | class MSVCCompiler(_MSVCCompiler): 42 | def __init__(self, verbose=0, dry_run=0, force=0): 43 | _MSVCCompiler.__init__(self, verbose, dry_run, force) 44 | 45 | def initialize(self, plat_name=None): 46 | # The 'lib' and 'include' variables may be overwritten 47 | # by MSVCCompiler.initialize, so save them for later merge. 48 | environ_lib = os.getenv('lib', '') 49 | environ_include = os.getenv('include', '') 50 | _MSVCCompiler.initialize(self, plat_name) 51 | 52 | # Merge current and previous values of 'lib' and 'include' 53 | os.environ['lib'] = _merge(environ_lib, os.environ['lib']) 54 | os.environ['include'] = _merge(environ_include, os.environ['include']) 55 | 56 | # msvc9 building for 32 bits requires SSE2 to work around a 57 | # compiler bug. 58 | if platform_bits == 32: 59 | self.compile_options += ['/arch:SSE2'] 60 | self.compile_options_debug += ['/arch:SSE2'] 61 | -------------------------------------------------------------------------------- /dist/numpy/distutils/msvccompiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/msvccompiler.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/npy_pkg_config.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/npy_pkg_config.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/numpy_distribution.py: -------------------------------------------------------------------------------- 1 | # XXX: Handle setuptools ? 2 | from __future__ import division, absolute_import, print_function 3 | 4 | from distutils.core import Distribution 5 | 6 | # This class is used because we add new files (sconscripts, and so on) with the 7 | # scons command 8 | class NumpyDistribution(Distribution): 9 | def __init__(self, attrs = None): 10 | # A list of (sconscripts, pre_hook, post_hook, src, parent_names) 11 | self.scons_data = [] 12 | # A list of installable libraries 13 | self.installed_libraries = [] 14 | # A dict of pkg_config files to generate/install 15 | self.installed_pkg_config = {} 16 | Distribution.__init__(self, attrs) 17 | 18 | def has_scons_scripts(self): 19 | return bool(self.scons_data) 20 | -------------------------------------------------------------------------------- /dist/numpy/distutils/numpy_distribution.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/numpy_distribution.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/pathccompiler.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from distutils.unixccompiler import UnixCCompiler 4 | 5 | class PathScaleCCompiler(UnixCCompiler): 6 | 7 | """ 8 | PathScale compiler compatible with an gcc built Python. 9 | """ 10 | 11 | compiler_type = 'pathcc' 12 | cc_exe = 'pathcc' 13 | cxx_exe = 'pathCC' 14 | 15 | def __init__ (self, verbose=0, dry_run=0, force=0): 16 | UnixCCompiler.__init__ (self, verbose, dry_run, force) 17 | cc_compiler = self.cc_exe 18 | cxx_compiler = self.cxx_exe 19 | self.set_executables(compiler=cc_compiler, 20 | compiler_so=cc_compiler, 21 | compiler_cxx=cxx_compiler, 22 | linker_exe=cc_compiler, 23 | linker_so=cc_compiler + ' -shared') 24 | -------------------------------------------------------------------------------- /dist/numpy/distutils/pathccompiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/pathccompiler.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | from __future__ import division, print_function 3 | 4 | def configuration(parent_package='',top_path=None): 5 | from numpy.distutils.misc_util import Configuration 6 | config = Configuration('distutils', parent_package, top_path) 7 | config.add_subpackage('command') 8 | config.add_subpackage('fcompiler') 9 | config.add_data_dir('tests') 10 | config.add_data_files('site.cfg') 11 | config.add_data_files('mingw/gfortran_vs2003_hack.c') 12 | config.make_config_py() 13 | return config 14 | 15 | if __name__ == '__main__': 16 | from numpy.distutils.core import setup 17 | setup(configuration=configuration) 18 | -------------------------------------------------------------------------------- /dist/numpy/distutils/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/system_info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/system_info.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/tests/test_exec_command.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/tests/test_exec_command.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/tests/test_fcompiler_gnu.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/tests/test_fcompiler_gnu.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/tests/test_fcompiler_intel.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import numpy.distutils.fcompiler 4 | from numpy.testing import TestCase, run_module_suite, assert_ 5 | 6 | 7 | intel_32bit_version_strings = [ 8 | ("Intel(R) Fortran Intel(R) 32-bit Compiler Professional for applications" 9 | "running on Intel(R) 32, Version 11.1", '11.1'), 10 | ] 11 | 12 | intel_64bit_version_strings = [ 13 | ("Intel(R) Fortran IA-64 Compiler Professional for applications" 14 | "running on IA-64, Version 11.0", '11.0'), 15 | ("Intel(R) Fortran Intel(R) 64 Compiler Professional for applications" 16 | "running on Intel(R) 64, Version 11.1", '11.1') 17 | ] 18 | 19 | class TestIntelFCompilerVersions(TestCase): 20 | def test_32bit_version(self): 21 | fc = numpy.distutils.fcompiler.new_fcompiler(compiler='intel') 22 | for vs, version in intel_32bit_version_strings: 23 | v = fc.version_match(vs) 24 | assert_(v == version) 25 | 26 | 27 | class TestIntelEM64TFCompilerVersions(TestCase): 28 | def test_64bit_version(self): 29 | fc = numpy.distutils.fcompiler.new_fcompiler(compiler='intelem') 30 | for vs, version in intel_64bit_version_strings: 31 | v = fc.version_match(vs) 32 | assert_(v == version) 33 | 34 | 35 | if __name__ == '__main__': 36 | run_module_suite() 37 | -------------------------------------------------------------------------------- /dist/numpy/distutils/tests/test_fcompiler_intel.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/tests/test_fcompiler_intel.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/tests/test_misc_util.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/tests/test_misc_util.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/tests/test_npy_pkg_config.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/tests/test_npy_pkg_config.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/tests/test_system_info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/tests/test_system_info.pyc -------------------------------------------------------------------------------- /dist/numpy/distutils/unixccompiler.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/distutils/unixccompiler.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/__init__.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | 5 | ref_dir = os.path.join(os.path.dirname(__file__)) 6 | 7 | __all__ = sorted(f[:-3] for f in os.listdir(ref_dir) if f.endswith('.py') and 8 | not f.startswith('__')) 9 | 10 | for f in __all__: 11 | __import__(__name__ + '.' + f) 12 | 13 | del f, ref_dir 14 | 15 | __doc__ = """\ 16 | Topical documentation 17 | ===================== 18 | 19 | The following topics are available: 20 | %s 21 | 22 | You can view them by 23 | 24 | >>> help(np.doc.TOPIC) #doctest: +SKIP 25 | 26 | """ % '\n- '.join([''] + __all__) 27 | 28 | __all__.extend(['__doc__']) 29 | -------------------------------------------------------------------------------- /dist/numpy/doc/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/basics.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/basics.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/broadcasting.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/broadcasting.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/byteswapping.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/byteswapping.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/constants.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/constants.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/creation.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/creation.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/glossary.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/glossary.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/indexing.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/indexing.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/internals.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/internals.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/misc.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/misc.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/structured_arrays.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/structured_arrays.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/subclassing.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/subclassing.pyc -------------------------------------------------------------------------------- /dist/numpy/doc/ufuncs.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/doc/ufuncs.pyc -------------------------------------------------------------------------------- /dist/numpy/dual.py: -------------------------------------------------------------------------------- 1 | """ 2 | Aliases for functions which may be accelerated by Scipy. 3 | 4 | Scipy_ can be built to use accelerated or otherwise improved libraries 5 | for FFTs, linear algebra, and special functions. This module allows 6 | developers to transparently support these accelerated functions when 7 | scipy is available but still support users who have only installed 8 | Numpy. 9 | 10 | .. _Scipy : http://www.scipy.org 11 | 12 | """ 13 | from __future__ import division, absolute_import, print_function 14 | 15 | # This module should be used for functions both in numpy and scipy if 16 | # you want to use the numpy version if available but the scipy version 17 | # otherwise. 18 | # Usage --- from numpy.dual import fft, inv 19 | 20 | __all__ = ['fft', 'ifft', 'fftn', 'ifftn', 'fft2', 'ifft2', 21 | 'norm', 'inv', 'svd', 'solve', 'det', 'eig', 'eigvals', 22 | 'eigh', 'eigvalsh', 'lstsq', 'pinv', 'cholesky', 'i0'] 23 | 24 | import numpy.linalg as linpkg 25 | import numpy.fft as fftpkg 26 | from numpy.lib import i0 27 | import sys 28 | 29 | 30 | fft = fftpkg.fft 31 | ifft = fftpkg.ifft 32 | fftn = fftpkg.fftn 33 | ifftn = fftpkg.ifftn 34 | fft2 = fftpkg.fft2 35 | ifft2 = fftpkg.ifft2 36 | 37 | norm = linpkg.norm 38 | inv = linpkg.inv 39 | svd = linpkg.svd 40 | solve = linpkg.solve 41 | det = linpkg.det 42 | eig = linpkg.eig 43 | eigvals = linpkg.eigvals 44 | eigh = linpkg.eigh 45 | eigvalsh = linpkg.eigvalsh 46 | lstsq = linpkg.lstsq 47 | pinv = linpkg.pinv 48 | cholesky = linpkg.cholesky 49 | 50 | _restore_dict = {} 51 | 52 | def register_func(name, func): 53 | if name not in __all__: 54 | raise ValueError("%s not a dual function." % name) 55 | f = sys._getframe(0).f_globals 56 | _restore_dict[name] = f[name] 57 | f[name] = func 58 | 59 | def restore_func(name): 60 | if name not in __all__: 61 | raise ValueError("%s not a dual function." % name) 62 | try: 63 | val = _restore_dict[name] 64 | except KeyError: 65 | return 66 | else: 67 | sys._getframe(0).f_globals[name] = val 68 | 69 | def restore_all(): 70 | for name in _restore_dict.keys(): 71 | restore_func(name) 72 | -------------------------------------------------------------------------------- /dist/numpy/dual.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/dual.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/__main__.py: -------------------------------------------------------------------------------- 1 | # See http://cens.ioc.ee/projects/f2py2e/ 2 | from __future__ import division, print_function 3 | 4 | import os 5 | import sys 6 | for mode in ["g3-numpy", "2e-numeric", "2e-numarray", "2e-numpy"]: 7 | try: 8 | i = sys.argv.index("--" + mode) 9 | del sys.argv[i] 10 | break 11 | except ValueError: 12 | pass 13 | os.environ["NO_SCIPY_IMPORT"] = "f2py" 14 | if mode == "g3-numpy": 15 | sys.stderr.write("G3 f2py support is not implemented, yet.\\n") 16 | sys.exit(1) 17 | elif mode == "2e-numeric": 18 | from f2py2e import main 19 | elif mode == "2e-numarray": 20 | sys.argv.append("-DNUMARRAY") 21 | from f2py2e import main 22 | elif mode == "2e-numpy": 23 | from numpy.f2py import main 24 | else: 25 | sys.stderr.write("Unknown mode: " + repr(mode) + "\\n") 26 | sys.exit(1) 27 | main() 28 | -------------------------------------------------------------------------------- /dist/numpy/f2py/__main__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/__main__.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/__version__.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | major = 2 4 | 5 | try: 6 | from __svn_version__ import version 7 | version_info = (major, version) 8 | version = '%s_%s' % version_info 9 | except (ImportError, ValueError): 10 | version = str(major) 11 | -------------------------------------------------------------------------------- /dist/numpy/f2py/__version__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/__version__.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/auxfuncs.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/auxfuncs.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/capi_maps.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/capi_maps.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/cb_rules.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/cb_rules.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/cfuncs.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/cfuncs.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/common_rules.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/common_rules.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/crackfortran.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/crackfortran.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/diagnose.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/diagnose.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/f2py2e.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/f2py2e.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/f2py_testing.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | import re 5 | 6 | from numpy.testing.utils import jiffies, memusage 7 | 8 | 9 | def cmdline(): 10 | m = re.compile(r'\A\d+\Z') 11 | args = [] 12 | repeat = 1 13 | for a in sys.argv[1:]: 14 | if m.match(a): 15 | repeat = eval(a) 16 | else: 17 | args.append(a) 18 | f2py_opts = ' '.join(args) 19 | return repeat, f2py_opts 20 | 21 | 22 | def run(runtest, test_functions, repeat=1): 23 | l = [(t, repr(t.__doc__.split('\n')[1].strip())) for t in test_functions] 24 | start_memusage = memusage() 25 | diff_memusage = None 26 | start_jiffies = jiffies() 27 | i = 0 28 | while i < repeat: 29 | i += 1 30 | for t, fname in l: 31 | runtest(t) 32 | if start_memusage is None: 33 | continue 34 | if diff_memusage is None: 35 | diff_memusage = memusage() - start_memusage 36 | else: 37 | diff_memusage2 = memusage() - start_memusage 38 | if diff_memusage2 != diff_memusage: 39 | print('memory usage change at step %i:' % i, 40 | diff_memusage2 - diff_memusage, 41 | fname) 42 | diff_memusage = diff_memusage2 43 | current_memusage = memusage() 44 | print('run', repeat * len(test_functions), 'tests', 45 | 'in %.2f seconds' % ((jiffies() - start_jiffies) / 100.0)) 46 | if start_memusage: 47 | print('initial virtual memory size:', start_memusage, 'bytes') 48 | print('current virtual memory size:', current_memusage, 'bytes') 49 | -------------------------------------------------------------------------------- /dist/numpy/f2py/f2py_testing.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/f2py_testing.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/f90mod_rules.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/f90mod_rules.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/func2subr.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/func2subr.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/info.py: -------------------------------------------------------------------------------- 1 | """Fortran to Python Interface Generator. 2 | 3 | """ 4 | from __future__ import division, absolute_import, print_function 5 | 6 | postpone_import = True 7 | -------------------------------------------------------------------------------- /dist/numpy/f2py/info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/info.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/rules.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/rules.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap: -------------------------------------------------------------------------------- 1 | dict(real=dict(rk="double")) 2 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/assumed_shape/foo_free.f90: -------------------------------------------------------------------------------- 1 | 2 | subroutine sum(x, res) 3 | implicit none 4 | real, intent(in) :: x(:) 5 | real, intent(out) :: res 6 | 7 | integer :: i 8 | 9 | !print *, "sum: size(x) = ", size(x) 10 | 11 | res = 0.0 12 | 13 | do i = 1, size(x) 14 | res = res + x(i) 15 | enddo 16 | 17 | end subroutine sum 18 | 19 | function fsum(x) result (res) 20 | implicit none 21 | real, intent(in) :: x(:) 22 | real :: res 23 | 24 | integer :: i 25 | 26 | !print *, "fsum: size(x) = ", size(x) 27 | 28 | res = 0.0 29 | 30 | do i = 1, size(x) 31 | res = res + x(i) 32 | enddo 33 | 34 | end function fsum 35 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/assumed_shape/foo_mod.f90: -------------------------------------------------------------------------------- 1 | 2 | module mod 3 | 4 | contains 5 | 6 | subroutine sum(x, res) 7 | implicit none 8 | real, intent(in) :: x(:) 9 | real, intent(out) :: res 10 | 11 | integer :: i 12 | 13 | !print *, "sum: size(x) = ", size(x) 14 | 15 | res = 0.0 16 | 17 | do i = 1, size(x) 18 | res = res + x(i) 19 | enddo 20 | 21 | end subroutine sum 22 | 23 | function fsum(x) result (res) 24 | implicit none 25 | real, intent(in) :: x(:) 26 | real :: res 27 | 28 | integer :: i 29 | 30 | !print *, "fsum: size(x) = ", size(x) 31 | 32 | res = 0.0 33 | 34 | do i = 1, size(x) 35 | res = res + x(i) 36 | enddo 37 | 38 | end function fsum 39 | 40 | 41 | end module mod 42 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/assumed_shape/foo_use.f90: -------------------------------------------------------------------------------- 1 | subroutine sum_with_use(x, res) 2 | use precision 3 | 4 | implicit none 5 | 6 | real(kind=rk), intent(in) :: x(:) 7 | real(kind=rk), intent(out) :: res 8 | 9 | integer :: i 10 | 11 | !print *, "size(x) = ", size(x) 12 | 13 | res = 0.0 14 | 15 | do i = 1, size(x) 16 | res = res + x(i) 17 | enddo 18 | 19 | end subroutine 20 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/assumed_shape/precision.f90: -------------------------------------------------------------------------------- 1 | module precision 2 | integer, parameter :: rk = selected_real_kind(8) 3 | integer, parameter :: ik = selected_real_kind(4) 4 | end module 5 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/kind/foo.f90: -------------------------------------------------------------------------------- 1 | 2 | 3 | subroutine selectedrealkind(p, r, res) 4 | implicit none 5 | 6 | integer, intent(in) :: p, r 7 | !f2py integer :: r=0 8 | integer, intent(out) :: res 9 | res = selected_real_kind(p, r) 10 | 11 | end subroutine 12 | 13 | subroutine selectedintkind(p, res) 14 | implicit none 15 | 16 | integer, intent(in) :: p 17 | integer, intent(out) :: res 18 | res = selected_int_kind(p) 19 | 20 | end subroutine 21 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/mixed/foo.f: -------------------------------------------------------------------------------- 1 | subroutine bar11(a) 2 | cf2py intent(out) a 3 | integer a 4 | a = 11 5 | end 6 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/mixed/foo_fixed.f90: -------------------------------------------------------------------------------- 1 | module foo_fixed 2 | contains 3 | subroutine bar12(a) 4 | !f2py intent(out) a 5 | integer a 6 | a = 12 7 | end subroutine bar12 8 | end module foo_fixed 9 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/mixed/foo_free.f90: -------------------------------------------------------------------------------- 1 | module foo_free 2 | contains 3 | subroutine bar13(a) 4 | !f2py intent(out) a 5 | integer a 6 | a = 13 7 | end subroutine bar13 8 | end module foo_free 9 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/regression/inout.f90: -------------------------------------------------------------------------------- 1 | ! Check that intent(in out) translates as intent(inout). 2 | ! The separation seems to be a common usage. 3 | subroutine foo(x) 4 | implicit none 5 | real(4), intent(in out) :: x 6 | dimension x(3) 7 | x(1) = x(1) + x(2) + x(3) 8 | return 9 | end 10 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/src/size/foo.f90: -------------------------------------------------------------------------------- 1 | 2 | subroutine foo(a, n, m, b) 3 | implicit none 4 | 5 | real, intent(in) :: a(n, m) 6 | integer, intent(in) :: n, m 7 | real, intent(out) :: b(size(a, 1)) 8 | 9 | integer :: i 10 | 11 | do i = 1, size(b) 12 | b(i) = sum(a(i,:)) 13 | enddo 14 | end subroutine 15 | 16 | subroutine trans(x,y) 17 | implicit none 18 | real, intent(in), dimension(:,:) :: x 19 | real, intent(out), dimension( size(x,2), size(x,1) ) :: y 20 | integer :: N, M, i, j 21 | N = size(x,1) 22 | M = size(x,2) 23 | DO i=1,N 24 | do j=1,M 25 | y(j,i) = x(i,j) 26 | END DO 27 | END DO 28 | end subroutine trans 29 | 30 | subroutine flatten(x,y) 31 | implicit none 32 | real, intent(in), dimension(:,:) :: x 33 | real, intent(out), dimension( size(x) ) :: y 34 | integer :: N, M, i, j, k 35 | N = size(x,1) 36 | M = size(x,2) 37 | k = 1 38 | DO i=1,N 39 | do j=1,M 40 | y(k) = x(i,j) 41 | k = k + 1 42 | END DO 43 | END DO 44 | end subroutine flatten 45 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_array_from_pyobj.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_array_from_pyobj.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_assumed_shape.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | 5 | from numpy.testing import run_module_suite, assert_, dec 6 | import util 7 | 8 | 9 | def _path(*a): 10 | return os.path.join(*((os.path.dirname(__file__),) + a)) 11 | 12 | 13 | class TestAssumedShapeSumExample(util.F2PyTest): 14 | sources = [_path('src', 'assumed_shape', 'foo_free.f90'), 15 | _path('src', 'assumed_shape', 'foo_use.f90'), 16 | _path('src', 'assumed_shape', 'precision.f90'), 17 | _path('src', 'assumed_shape', 'foo_mod.f90'), 18 | ] 19 | 20 | @dec.slow 21 | def test_all(self): 22 | r = self.module.fsum([1, 2]) 23 | assert_(r == 3, repr(r)) 24 | r = self.module.sum([1, 2]) 25 | assert_(r == 3, repr(r)) 26 | r = self.module.sum_with_use([1, 2]) 27 | assert_(r == 3, repr(r)) 28 | 29 | r = self.module.mod.sum([1, 2]) 30 | assert_(r == 3, repr(r)) 31 | r = self.module.mod.fsum([1, 2]) 32 | assert_(r == 3, repr(r)) 33 | 34 | if __name__ == "__main__": 35 | run_module_suite() 36 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_assumed_shape.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_assumed_shape.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_callback.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_callback.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_kind.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | 5 | from numpy.testing import run_module_suite, assert_, dec 6 | from numpy.f2py.crackfortran import ( 7 | _selected_int_kind_func as selected_int_kind, 8 | _selected_real_kind_func as selected_real_kind 9 | ) 10 | import util 11 | 12 | 13 | def _path(*a): 14 | return os.path.join(*((os.path.dirname(__file__),) + a)) 15 | 16 | 17 | class TestKind(util.F2PyTest): 18 | sources = [_path('src', 'kind', 'foo.f90')] 19 | 20 | @dec.slow 21 | def test_all(self): 22 | selectedrealkind = self.module.selectedrealkind 23 | selectedintkind = self.module.selectedintkind 24 | 25 | for i in range(40): 26 | assert_(selectedintkind(i) in [selected_int_kind(i), -1], 27 | 'selectedintkind(%s): expected %r but got %r' % 28 | (i, selected_int_kind(i), selectedintkind(i))) 29 | 30 | for i in range(20): 31 | assert_(selectedrealkind(i) in [selected_real_kind(i), -1], 32 | 'selectedrealkind(%s): expected %r but got %r' % 33 | (i, selected_real_kind(i), selectedrealkind(i))) 34 | 35 | if __name__ == "__main__": 36 | run_module_suite() 37 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_kind.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_kind.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_mixed.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | import textwrap 5 | 6 | from numpy.testing import run_module_suite, assert_, assert_equal, dec 7 | import util 8 | 9 | 10 | def _path(*a): 11 | return os.path.join(*((os.path.dirname(__file__),) + a)) 12 | 13 | 14 | class TestMixed(util.F2PyTest): 15 | sources = [_path('src', 'mixed', 'foo.f'), 16 | _path('src', 'mixed', 'foo_fixed.f90'), 17 | _path('src', 'mixed', 'foo_free.f90')] 18 | 19 | @dec.slow 20 | def test_all(self): 21 | assert_(self.module.bar11() == 11) 22 | assert_(self.module.foo_fixed.bar12() == 12) 23 | assert_(self.module.foo_free.bar13() == 13) 24 | 25 | @dec.slow 26 | def test_docstring(self): 27 | expected = """ 28 | a = bar11() 29 | 30 | Wrapper for ``bar11``. 31 | 32 | Returns 33 | ------- 34 | a : int 35 | """ 36 | assert_equal(self.module.bar11.__doc__, 37 | textwrap.dedent(expected).lstrip()) 38 | 39 | if __name__ == "__main__": 40 | run_module_suite() 41 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_mixed.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_mixed.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_regression.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | import math 5 | 6 | import numpy as np 7 | from numpy.testing import dec, assert_raises, assert_equal 8 | 9 | import util 10 | 11 | 12 | def _path(*a): 13 | return os.path.join(*((os.path.dirname(__file__),) + a)) 14 | 15 | 16 | class TestIntentInOut(util.F2PyTest): 17 | # Check that intent(in out) translates as intent(inout) 18 | sources = [_path('src', 'regression', 'inout.f90')] 19 | 20 | @dec.slow 21 | def test_inout(self): 22 | # non-contiguous should raise error 23 | x = np.arange(6, dtype=np.float32)[::2] 24 | assert_raises(ValueError, self.module.foo, x) 25 | 26 | # check values with contiguous array 27 | x = np.arange(3, dtype=np.float32) 28 | self.module.foo(x) 29 | assert_equal(x, [3, 1, 2]) 30 | 31 | 32 | if __name__ == "__main__": 33 | import nose 34 | nose.runmodule() 35 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_regression.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_regression.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_return_character.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_return_character.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_return_complex.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_return_complex.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_return_integer.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_return_integer.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_return_logical.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_return_logical.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_return_real.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_return_real.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_size.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import os 4 | 5 | from numpy.testing import run_module_suite, assert_equal, dec 6 | import util 7 | 8 | 9 | def _path(*a): 10 | return os.path.join(*((os.path.dirname(__file__),) + a)) 11 | 12 | 13 | class TestSizeSumExample(util.F2PyTest): 14 | sources = [_path('src', 'size', 'foo.f90')] 15 | 16 | @dec.slow 17 | def test_all(self): 18 | r = self.module.foo([[1, 2]]) 19 | assert_equal(r, [3], repr(r)) 20 | 21 | r = self.module.foo([[1, 2], [3, 4]]) 22 | assert_equal(r, [3, 7], repr(r)) 23 | 24 | r = self.module.foo([[1, 2], [3, 4], [5, 6]]) 25 | assert_equal(r, [3, 7, 11], repr(r)) 26 | 27 | @dec.slow 28 | def test_transpose(self): 29 | r = self.module.trans([[1, 2]]) 30 | assert_equal(r, [[1], [2]], repr(r)) 31 | 32 | r = self.module.trans([[1, 2, 3], [4, 5, 6]]) 33 | assert_equal(r, [[1, 4], [2, 5], [3, 6]], repr(r)) 34 | 35 | @dec.slow 36 | def test_flatten(self): 37 | r = self.module.flatten([[1, 2]]) 38 | assert_equal(r, [1, 2], repr(r)) 39 | 40 | r = self.module.flatten([[1, 2, 3], [4, 5, 6]]) 41 | assert_equal(r, [1, 2, 3, 4, 5, 6], repr(r)) 42 | 43 | if __name__ == "__main__": 44 | run_module_suite() 45 | -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/test_size.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/test_size.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/tests/util.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/tests/util.pyc -------------------------------------------------------------------------------- /dist/numpy/f2py/use_rules.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/f2py/use_rules.pyc -------------------------------------------------------------------------------- /dist/numpy/fft/__init__.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | # To get sub-modules 4 | from .info import __doc__ 5 | 6 | from .fftpack import * 7 | from .helper import * 8 | 9 | from numpy.testing.nosetester import _numpy_tester 10 | test = _numpy_tester().test 11 | bench = _numpy_tester().bench 12 | -------------------------------------------------------------------------------- /dist/numpy/fft/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/fft/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/fft/fftpack.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/fft/fftpack.pyc -------------------------------------------------------------------------------- /dist/numpy/fft/helper.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/fft/helper.pyc -------------------------------------------------------------------------------- /dist/numpy/fft/info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/fft/info.pyc -------------------------------------------------------------------------------- /dist/numpy/fft/setup.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, print_function 2 | 3 | 4 | def configuration(parent_package='',top_path=None): 5 | from numpy.distutils.misc_util import Configuration 6 | config = Configuration('fft', parent_package, top_path) 7 | 8 | config.add_data_dir('tests') 9 | 10 | # Configure fftpack_lite 11 | config.add_extension('fftpack_lite', 12 | sources=['fftpack_litemodule.c', 'fftpack.c'] 13 | ) 14 | 15 | return config 16 | 17 | if __name__ == '__main__': 18 | from numpy.distutils.core import setup 19 | setup(configuration=configuration) 20 | -------------------------------------------------------------------------------- /dist/numpy/fft/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/fft/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/fft/tests/test_fftpack.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/fft/tests/test_fftpack.pyc -------------------------------------------------------------------------------- /dist/numpy/fft/tests/test_helper.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/fft/tests/test_helper.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/__init__.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import math 4 | 5 | from .info import __doc__ 6 | from numpy.version import version as __version__ 7 | 8 | from .type_check import * 9 | from .index_tricks import * 10 | from .function_base import * 11 | from .nanfunctions import * 12 | from .shape_base import * 13 | from .stride_tricks import * 14 | from .twodim_base import * 15 | from .ufunclike import * 16 | 17 | from . import scimath as emath 18 | from .polynomial import * 19 | #import convertcode 20 | from .utils import * 21 | from .arraysetops import * 22 | from .npyio import * 23 | from .financial import * 24 | from .arrayterator import Arrayterator 25 | from .arraypad import * 26 | from ._version import * 27 | 28 | __all__ = ['emath', 'math'] 29 | __all__ += type_check.__all__ 30 | __all__ += index_tricks.__all__ 31 | __all__ += function_base.__all__ 32 | __all__ += shape_base.__all__ 33 | __all__ += stride_tricks.__all__ 34 | __all__ += twodim_base.__all__ 35 | __all__ += ufunclike.__all__ 36 | __all__ += arraypad.__all__ 37 | __all__ += polynomial.__all__ 38 | __all__ += utils.__all__ 39 | __all__ += arraysetops.__all__ 40 | __all__ += npyio.__all__ 41 | __all__ += financial.__all__ 42 | __all__ += nanfunctions.__all__ 43 | 44 | from numpy.testing.nosetester import _numpy_tester 45 | test = _numpy_tester().test 46 | bench = _numpy_tester().bench 47 | -------------------------------------------------------------------------------- /dist/numpy/lib/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/_datasource.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/_datasource.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/_iotools.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/_iotools.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/_version.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/_version.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/arraypad.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/arraypad.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/arraysetops.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/arraysetops.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/arrayterator.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/arrayterator.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/financial.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/financial.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/format.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/format.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/function_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/function_base.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/index_tricks.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/index_tricks.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/info.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/nanfunctions.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/nanfunctions.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/npyio.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/npyio.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/polynomial.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/polynomial.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/recfunctions.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/recfunctions.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/scimath.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/scimath.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/setup.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, print_function 2 | 3 | def configuration(parent_package='',top_path=None): 4 | from numpy.distutils.misc_util import Configuration 5 | 6 | config = Configuration('lib', parent_package, top_path) 7 | config.add_data_dir('tests') 8 | return config 9 | 10 | if __name__ == '__main__': 11 | from numpy.distutils.core import setup 12 | setup(configuration=configuration) 13 | -------------------------------------------------------------------------------- /dist/numpy/lib/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/shape_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/shape_base.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/stride_tricks.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/stride_tricks.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/data/py2-objarr.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/data/py2-objarr.npy -------------------------------------------------------------------------------- /dist/numpy/lib/tests/data/py2-objarr.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/data/py2-objarr.npz -------------------------------------------------------------------------------- /dist/numpy/lib/tests/data/py3-objarr.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/data/py3-objarr.npy -------------------------------------------------------------------------------- /dist/numpy/lib/tests/data/py3-objarr.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/data/py3-objarr.npz -------------------------------------------------------------------------------- /dist/numpy/lib/tests/data/python3.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/data/python3.npy -------------------------------------------------------------------------------- /dist/numpy/lib/tests/data/win64python2.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/data/win64python2.npy -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test__datasource.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test__datasource.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test__iotools.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test__iotools.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test__version.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test__version.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_arraypad.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_arraypad.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_arraysetops.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_arraysetops.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_arrayterator.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from operator import mul 4 | from functools import reduce 5 | 6 | import numpy as np 7 | from numpy.random import randint 8 | from numpy.lib import Arrayterator 9 | from numpy.testing import assert_ 10 | 11 | 12 | def test(): 13 | np.random.seed(np.arange(10)) 14 | 15 | # Create a random array 16 | ndims = randint(5)+1 17 | shape = tuple(randint(10)+1 for dim in range(ndims)) 18 | els = reduce(mul, shape) 19 | a = np.arange(els) 20 | a.shape = shape 21 | 22 | buf_size = randint(2*els) 23 | b = Arrayterator(a, buf_size) 24 | 25 | # Check that each block has at most ``buf_size`` elements 26 | for block in b: 27 | assert_(len(block.flat) <= (buf_size or els)) 28 | 29 | # Check that all elements are iterated correctly 30 | assert_(list(b.flat) == list(a.flat)) 31 | 32 | # Slice arrayterator 33 | start = [randint(dim) for dim in shape] 34 | stop = [randint(dim)+1 for dim in shape] 35 | step = [randint(dim)+1 for dim in shape] 36 | slice_ = tuple(slice(*t) for t in zip(start, stop, step)) 37 | c = b[slice_] 38 | d = a[slice_] 39 | 40 | # Check that each block has at most ``buf_size`` elements 41 | for block in c: 42 | assert_(len(block.flat) <= (buf_size or els)) 43 | 44 | # Check that the arrayterator is sliced correctly 45 | assert_(np.all(c.__array__() == d)) 46 | 47 | # Check that all elements are iterated correctly 48 | assert_(list(c.flat) == list(d.flat)) 49 | 50 | if __name__ == '__main__': 51 | from numpy.testing import run_module_suite 52 | run_module_suite() 53 | -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_arrayterator.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_arrayterator.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_financial.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_financial.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_format.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_format.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_function_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_function_base.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_index_tricks.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_index_tricks.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_io.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_io.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_nanfunctions.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_nanfunctions.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_packbits.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import numpy as np 4 | from numpy.testing import assert_array_equal, assert_equal, assert_raises 5 | 6 | 7 | def test_packbits(): 8 | # Copied from the docstring. 9 | a = [[[1, 0, 1], [0, 1, 0]], 10 | [[1, 1, 0], [0, 0, 1]]] 11 | for dtype in [np.bool, np.uint8, np.int]: 12 | arr = np.array(a, dtype=dtype) 13 | b = np.packbits(arr, axis=-1) 14 | assert_equal(b.dtype, np.uint8) 15 | assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]])) 16 | 17 | assert_raises(TypeError, np.packbits, np.array(a, dtype=float)) 18 | 19 | 20 | def test_unpackbits(): 21 | # Copied from the docstring. 22 | a = np.array([[2], [7], [23]], dtype=np.uint8) 23 | b = np.unpackbits(a, axis=1) 24 | assert_equal(b.dtype, np.uint8) 25 | assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0], 26 | [0, 0, 0, 0, 0, 1, 1, 1], 27 | [0, 0, 0, 1, 0, 1, 1, 1]])) 28 | -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_packbits.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_packbits.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_polynomial.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_polynomial.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_recfunctions.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_recfunctions.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_regression.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_regression.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_shape_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_shape_base.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_stride_tricks.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_stride_tricks.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_twodim_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_twodim_base.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_type_check.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_type_check.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_ufunclike.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import numpy.core as nx 4 | import numpy.lib.ufunclike as ufl 5 | from numpy.testing import ( 6 | run_module_suite, TestCase, assert_, assert_equal, assert_array_equal 7 | ) 8 | 9 | 10 | class TestUfunclike(TestCase): 11 | 12 | def test_isposinf(self): 13 | a = nx.array([nx.inf, -nx.inf, nx.nan, 0.0, 3.0, -3.0]) 14 | out = nx.zeros(a.shape, bool) 15 | tgt = nx.array([True, False, False, False, False, False]) 16 | 17 | res = ufl.isposinf(a) 18 | assert_equal(res, tgt) 19 | res = ufl.isposinf(a, out) 20 | assert_equal(res, tgt) 21 | assert_equal(out, tgt) 22 | 23 | def test_isneginf(self): 24 | a = nx.array([nx.inf, -nx.inf, nx.nan, 0.0, 3.0, -3.0]) 25 | out = nx.zeros(a.shape, bool) 26 | tgt = nx.array([False, True, False, False, False, False]) 27 | 28 | res = ufl.isneginf(a) 29 | assert_equal(res, tgt) 30 | res = ufl.isneginf(a, out) 31 | assert_equal(res, tgt) 32 | assert_equal(out, tgt) 33 | 34 | def test_fix(self): 35 | a = nx.array([[1.0, 1.1, 1.5, 1.8], [-1.0, -1.1, -1.5, -1.8]]) 36 | out = nx.zeros(a.shape, float) 37 | tgt = nx.array([[1., 1., 1., 1.], [-1., -1., -1., -1.]]) 38 | 39 | res = ufl.fix(a) 40 | assert_equal(res, tgt) 41 | res = ufl.fix(a, out) 42 | assert_equal(res, tgt) 43 | assert_equal(out, tgt) 44 | assert_equal(ufl.fix(3.14), 3) 45 | 46 | def test_fix_with_subclass(self): 47 | class MyArray(nx.ndarray): 48 | def __new__(cls, data, metadata=None): 49 | res = nx.array(data, copy=True).view(cls) 50 | res.metadata = metadata 51 | return res 52 | 53 | def __array_wrap__(self, obj, context=None): 54 | obj.metadata = self.metadata 55 | return obj 56 | 57 | a = nx.array([1.1, -1.1]) 58 | m = MyArray(a, metadata='foo') 59 | f = ufl.fix(m) 60 | assert_array_equal(f, nx.array([1, -1])) 61 | assert_(isinstance(f, MyArray)) 62 | assert_equal(f.metadata, 'foo') 63 | 64 | if __name__ == "__main__": 65 | run_module_suite() 66 | -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_ufunclike.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_ufunclike.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_utils.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | from numpy.core import arange 5 | from numpy.testing import ( 6 | run_module_suite, assert_, assert_equal, dec 7 | ) 8 | from numpy.lib import deprecate 9 | import numpy.lib.utils as utils 10 | 11 | if sys.version_info[0] >= 3: 12 | from io import StringIO 13 | else: 14 | from StringIO import StringIO 15 | 16 | 17 | @dec.skipif(sys.flags.optimize == 2) 18 | def test_lookfor(): 19 | out = StringIO() 20 | utils.lookfor('eigenvalue', module='numpy', output=out, 21 | import_modules=False) 22 | out = out.getvalue() 23 | assert_('numpy.linalg.eig' in out) 24 | 25 | 26 | @deprecate 27 | def old_func(self, x): 28 | return x 29 | 30 | 31 | @deprecate(message="Rather use new_func2") 32 | def old_func2(self, x): 33 | return x 34 | 35 | 36 | def old_func3(self, x): 37 | return x 38 | new_func3 = deprecate(old_func3, old_name="old_func3", new_name="new_func3") 39 | 40 | 41 | def test_deprecate_decorator(): 42 | assert_('deprecated' in old_func.__doc__) 43 | 44 | 45 | def test_deprecate_decorator_message(): 46 | assert_('Rather use new_func2' in old_func2.__doc__) 47 | 48 | 49 | def test_deprecate_fn(): 50 | assert_('old_func3' in new_func3.__doc__) 51 | assert_('new_func3' in new_func3.__doc__) 52 | 53 | 54 | def test_safe_eval_nameconstant(): 55 | # Test if safe_eval supports Python 3.4 _ast.NameConstant 56 | utils.safe_eval('None') 57 | 58 | 59 | def test_byte_bounds(): 60 | a = arange(12).reshape(3, 4) 61 | low, high = utils.byte_bounds(a) 62 | assert_equal(high - low, a.size * a.itemsize) 63 | 64 | 65 | if __name__ == "__main__": 66 | run_module_suite() 67 | -------------------------------------------------------------------------------- /dist/numpy/lib/tests/test_utils.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/tests/test_utils.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/twodim_base.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/twodim_base.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/type_check.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/type_check.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/ufunclike.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/ufunclike.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/user_array.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/user_array.pyc -------------------------------------------------------------------------------- /dist/numpy/lib/utils.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/lib/utils.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/info.py: -------------------------------------------------------------------------------- 1 | """\ 2 | Core Linear Algebra Tools 3 | ------------------------- 4 | Linear algebra basics: 5 | 6 | - norm Vector or matrix norm 7 | - inv Inverse of a square matrix 8 | - solve Solve a linear system of equations 9 | - det Determinant of a square matrix 10 | - lstsq Solve linear least-squares problem 11 | - pinv Pseudo-inverse (Moore-Penrose) calculated using a singular 12 | value decomposition 13 | - matrix_power Integer power of a square matrix 14 | 15 | Eigenvalues and decompositions: 16 | 17 | - eig Eigenvalues and vectors of a square matrix 18 | - eigh Eigenvalues and eigenvectors of a Hermitian matrix 19 | - eigvals Eigenvalues of a square matrix 20 | - eigvalsh Eigenvalues of a Hermitian matrix 21 | - qr QR decomposition of a matrix 22 | - svd Singular value decomposition of a matrix 23 | - cholesky Cholesky decomposition of a matrix 24 | 25 | Tensor operations: 26 | 27 | - tensorsolve Solve a linear tensor equation 28 | - tensorinv Calculate an inverse of a tensor 29 | 30 | Exceptions: 31 | 32 | - LinAlgError Indicates a failed linear algebra operation 33 | 34 | """ 35 | from __future__ import division, absolute_import, print_function 36 | 37 | depends = ['core'] 38 | -------------------------------------------------------------------------------- /dist/numpy/linalg/info.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/info.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/linalg.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/linalg.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/setup.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, print_function 2 | 3 | import os 4 | import sys 5 | 6 | def configuration(parent_package='', top_path=None): 7 | from numpy.distutils.misc_util import Configuration 8 | from numpy.distutils.system_info import get_info 9 | config = Configuration('linalg', parent_package, top_path) 10 | 11 | config.add_data_dir('tests') 12 | 13 | # Configure lapack_lite 14 | 15 | src_dir = 'lapack_lite' 16 | lapack_lite_src = [ 17 | os.path.join(src_dir, 'python_xerbla.c'), 18 | os.path.join(src_dir, 'zlapack_lite.c'), 19 | os.path.join(src_dir, 'dlapack_lite.c'), 20 | os.path.join(src_dir, 'blas_lite.c'), 21 | os.path.join(src_dir, 'dlamch.c'), 22 | os.path.join(src_dir, 'f2c_lite.c'), 23 | ] 24 | all_sources = config.paths(lapack_lite_src) 25 | 26 | lapack_info = get_info('lapack_opt', 0) # and {} 27 | 28 | def get_lapack_lite_sources(ext, build_dir): 29 | if not lapack_info: 30 | print("### Warning: Using unoptimized lapack ###") 31 | return all_sources 32 | else: 33 | if sys.platform == 'win32': 34 | print("### Warning: python_xerbla.c is disabled ###") 35 | return [] 36 | return [all_sources[0]] 37 | 38 | config.add_extension( 39 | 'lapack_lite', 40 | sources=['lapack_litemodule.c', get_lapack_lite_sources], 41 | depends=['lapack_lite/f2c.h'], 42 | extra_info=lapack_info, 43 | ) 44 | 45 | # umath_linalg module 46 | config.add_extension( 47 | '_umath_linalg', 48 | sources=['umath_linalg.c.src', get_lapack_lite_sources], 49 | depends=['lapack_lite/f2c.h'], 50 | extra_info=lapack_info, 51 | libraries=['npymath'], 52 | ) 53 | return config 54 | 55 | if __name__ == '__main__': 56 | from numpy.distutils.core import setup 57 | setup(configuration=configuration) 58 | -------------------------------------------------------------------------------- /dist/numpy/linalg/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/tests/test_build.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | from subprocess import PIPE, Popen 4 | import sys 5 | import re 6 | 7 | from numpy.linalg import lapack_lite 8 | from numpy.testing import TestCase, dec, run_module_suite 9 | 10 | from numpy.compat import asbytes_nested 11 | 12 | 13 | class FindDependenciesLdd(object): 14 | 15 | def __init__(self): 16 | self.cmd = ['ldd'] 17 | 18 | try: 19 | p = Popen(self.cmd, stdout=PIPE, stderr=PIPE) 20 | stdout, stderr = p.communicate() 21 | except OSError: 22 | raise RuntimeError("command %s cannot be run" % self.cmd) 23 | 24 | def get_dependencies(self, lfile): 25 | p = Popen(self.cmd + [lfile], stdout=PIPE, stderr=PIPE) 26 | stdout, stderr = p.communicate() 27 | if not (p.returncode == 0): 28 | raise RuntimeError("failed dependencies check for %s" % lfile) 29 | 30 | return stdout 31 | 32 | def grep_dependencies(self, lfile, deps): 33 | stdout = self.get_dependencies(lfile) 34 | 35 | rdeps = dict([(dep, re.compile(dep)) for dep in deps]) 36 | founds = [] 37 | for l in stdout.splitlines(): 38 | for k, v in rdeps.items(): 39 | if v.search(l): 40 | founds.append(k) 41 | 42 | return founds 43 | 44 | 45 | class TestF77Mismatch(TestCase): 46 | 47 | @dec.skipif(not(sys.platform[:5] == 'linux'), 48 | "Skipping fortran compiler mismatch on non Linux platform") 49 | def test_lapack(self): 50 | f = FindDependenciesLdd() 51 | deps = f.grep_dependencies(lapack_lite.__file__, 52 | asbytes_nested(['libg2c', 'libgfortran'])) 53 | self.assertFalse(len(deps) > 1, 54 | """Both g77 and gfortran runtimes linked in lapack_lite ! This is likely to 55 | cause random crashes and wrong results. See numpy INSTALL.txt for more 56 | information.""") 57 | 58 | if __name__ == "__main__": 59 | run_module_suite() 60 | -------------------------------------------------------------------------------- /dist/numpy/linalg/tests/test_build.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/tests/test_build.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/tests/test_deprecations.py: -------------------------------------------------------------------------------- 1 | """Test deprecation and future warnings. 2 | 3 | """ 4 | from __future__ import division, absolute_import, print_function 5 | 6 | import numpy as np 7 | from numpy.testing import assert_warns, run_module_suite 8 | 9 | 10 | def test_qr_mode_full_future_warning(): 11 | """Check mode='full' FutureWarning. 12 | 13 | In numpy 1.8 the mode options 'full' and 'economic' in linalg.qr were 14 | deprecated. The release date will probably be sometime in the summer 15 | of 2013. 16 | 17 | """ 18 | a = np.eye(2) 19 | assert_warns(DeprecationWarning, np.linalg.qr, a, mode='full') 20 | assert_warns(DeprecationWarning, np.linalg.qr, a, mode='f') 21 | assert_warns(DeprecationWarning, np.linalg.qr, a, mode='economic') 22 | assert_warns(DeprecationWarning, np.linalg.qr, a, mode='e') 23 | 24 | 25 | if __name__ == "__main__": 26 | run_module_suite() 27 | -------------------------------------------------------------------------------- /dist/numpy/linalg/tests/test_deprecations.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/tests/test_deprecations.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/tests/test_linalg.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/tests/test_linalg.pyc -------------------------------------------------------------------------------- /dist/numpy/linalg/tests/test_regression.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/linalg/tests/test_regression.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/__init__.py: -------------------------------------------------------------------------------- 1 | """ 2 | ============= 3 | Masked Arrays 4 | ============= 5 | 6 | Arrays sometimes contain invalid or missing data. When doing operations 7 | on such arrays, we wish to suppress invalid values, which is the purpose masked 8 | arrays fulfill (an example of typical use is given below). 9 | 10 | For example, examine the following array: 11 | 12 | >>> x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan]) 13 | 14 | When we try to calculate the mean of the data, the result is undetermined: 15 | 16 | >>> np.mean(x) 17 | nan 18 | 19 | The mean is calculated using roughly ``np.sum(x)/len(x)``, but since 20 | any number added to ``NaN`` [1]_ produces ``NaN``, this doesn't work. Enter 21 | masked arrays: 22 | 23 | >>> m = np.ma.masked_array(x, np.isnan(x)) 24 | >>> m 25 | masked_array(data = [2.0 1.0 3.0 -- 5.0 2.0 3.0 --], 26 | mask = [False False False True False False False True], 27 | fill_value=1e+20) 28 | 29 | Here, we construct a masked array that suppress all ``NaN`` values. We 30 | may now proceed to calculate the mean of the other values: 31 | 32 | >>> np.mean(m) 33 | 2.6666666666666665 34 | 35 | .. [1] Not-a-Number, a floating point value that is the result of an 36 | invalid operation. 37 | 38 | .. moduleauthor:: Pierre Gerard-Marchant 39 | .. moduleauthor:: Jarrod Millman 40 | 41 | """ 42 | from __future__ import division, absolute_import, print_function 43 | 44 | from . import core 45 | from .core import * 46 | 47 | from . import extras 48 | from .extras import * 49 | 50 | __all__ = ['core', 'extras'] 51 | __all__ += core.__all__ 52 | __all__ += extras.__all__ 53 | 54 | from numpy.testing.nosetester import _numpy_tester 55 | test = _numpy_tester().test 56 | bench = _numpy_tester().bench 57 | -------------------------------------------------------------------------------- /dist/numpy/ma/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/bench.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/bench.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/core.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/core.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/extras.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/extras.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/mrecords.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/mrecords.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | from __future__ import division, print_function 3 | 4 | def configuration(parent_package='',top_path=None): 5 | from numpy.distutils.misc_util import Configuration 6 | config = Configuration('ma', parent_package, top_path) 7 | config.add_data_dir('tests') 8 | return config 9 | 10 | if __name__ == "__main__": 11 | from numpy.distutils.core import setup 12 | config = configuration(top_path='').todict() 13 | setup(**config) 14 | -------------------------------------------------------------------------------- /dist/numpy/ma/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/tests/test_core.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/tests/test_core.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/tests/test_extras.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/tests/test_extras.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/tests/test_mrecords.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/tests/test_mrecords.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/tests/test_old_ma.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/tests/test_old_ma.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/tests/test_regression.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/tests/test_regression.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/tests/test_subclassing.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/tests/test_subclassing.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/testutils.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/testutils.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/timer_comparison.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/timer_comparison.pyc -------------------------------------------------------------------------------- /dist/numpy/ma/version.py: -------------------------------------------------------------------------------- 1 | """Version number 2 | 3 | """ 4 | from __future__ import division, absolute_import, print_function 5 | 6 | version = '1.00' 7 | release = False 8 | 9 | if not release: 10 | from . import core 11 | from . import extras 12 | revision = [core.__revision__.split(':')[-1][:-1].strip(), 13 | extras.__revision__.split(':')[-1][:-1].strip(),] 14 | version += '.dev%04i' % max([int(rev) for rev in revision]) 15 | -------------------------------------------------------------------------------- /dist/numpy/ma/version.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/ma/version.pyc -------------------------------------------------------------------------------- /dist/numpy/matlib.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/matlib.pyc -------------------------------------------------------------------------------- /dist/numpy/matrixlib/__init__.py: -------------------------------------------------------------------------------- 1 | """Sub-package containing the matrix class and related functions. 2 | 3 | """ 4 | from __future__ import division, absolute_import, print_function 5 | 6 | from .defmatrix import * 7 | 8 | __all__ = defmatrix.__all__ 9 | 10 | from numpy.testing.nosetester import _numpy_tester 11 | test = _numpy_tester().test 12 | bench = _numpy_tester().bench 13 | -------------------------------------------------------------------------------- /dist/numpy/matrixlib/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/matrixlib/__init__.pyc -------------------------------------------------------------------------------- /dist/numpy/matrixlib/defmatrix.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/matrixlib/defmatrix.pyc -------------------------------------------------------------------------------- /dist/numpy/matrixlib/setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | from __future__ import division, print_function 3 | 4 | import os 5 | 6 | def configuration(parent_package='', top_path=None): 7 | from numpy.distutils.misc_util import Configuration 8 | config = Configuration('matrixlib', parent_package, top_path) 9 | config.add_data_dir('tests') 10 | return config 11 | 12 | if __name__ == "__main__": 13 | from numpy.distutils.core import setup 14 | config = configuration(top_path='').todict() 15 | setup(**config) 16 | -------------------------------------------------------------------------------- /dist/numpy/matrixlib/setup.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/matrixlib/setup.pyc -------------------------------------------------------------------------------- /dist/numpy/matrixlib/tests/test_defmatrix.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/matrixlib/tests/test_defmatrix.pyc -------------------------------------------------------------------------------- /dist/numpy/matrixlib/tests/test_multiarray.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import numpy as np 4 | from numpy.testing import ( 5 | TestCase, run_module_suite, assert_, assert_equal, assert_array_equal 6 | ) 7 | 8 | class TestView(TestCase): 9 | def test_type(self): 10 | x = np.array([1, 2, 3]) 11 | assert_(isinstance(x.view(np.matrix), np.matrix)) 12 | 13 | def test_keywords(self): 14 | x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)]) 15 | # We must be specific about the endianness here: 16 | y = x.view(dtype='>> 2+2 10 | #random: may vary on your system 11 | ''' 12 | 13 | # check the implicit "import numpy as np" 14 | def check_implicit_np(): 15 | ''' 16 | >>> np.array([1,2,3]) 17 | array([1, 2, 3]) 18 | ''' 19 | 20 | # there's some extraneous whitespace around the correct responses 21 | def check_whitespace_enabled(): 22 | ''' 23 | # whitespace after the 3 24 | >>> 1+2 25 | 3 26 | 27 | # whitespace before the 7 28 | >>> 3+4 29 | 7 30 | ''' 31 | 32 | def check_empty_output(): 33 | """ Check that no output does not cause an error. 34 | 35 | This is related to nose bug 445; the numpy plugin changed the 36 | doctest-result-variable default and therefore hit this bug: 37 | http://code.google.com/p/python-nose/issues/detail?id=445 38 | 39 | >>> a = 10 40 | """ 41 | 42 | def check_skip(): 43 | """ Check skip directive 44 | 45 | The test below should not run 46 | 47 | >>> 1/0 #doctest: +SKIP 48 | """ 49 | 50 | 51 | if __name__ == '__main__': 52 | # Run tests outside numpy test rig 53 | import nose 54 | from numpy.testing.noseclasses import NumpyDoctest 55 | argv = ['', __file__, '--with-numpydoctest'] 56 | nose.core.TestProgram(argv=argv, addplugins=[NumpyDoctest()]) 57 | -------------------------------------------------------------------------------- /dist/numpy/testing/tests/test_doctesting.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/testing/tests/test_doctesting.pyc -------------------------------------------------------------------------------- /dist/numpy/testing/tests/test_utils.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/testing/tests/test_utils.pyc -------------------------------------------------------------------------------- /dist/numpy/testing/utils.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/testing/utils.pyc -------------------------------------------------------------------------------- /dist/numpy/tests/test_ctypeslib.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/tests/test_ctypeslib.pyc -------------------------------------------------------------------------------- /dist/numpy/tests/test_matlib.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import numpy as np 4 | import numpy.matlib 5 | from numpy.testing import assert_array_equal, assert_, run_module_suite 6 | 7 | def test_empty(): 8 | x = numpy.matlib.empty((2,)) 9 | assert_(isinstance(x, np.matrix)) 10 | assert_(x.shape, (1, 2)) 11 | 12 | def test_ones(): 13 | assert_array_equal(numpy.matlib.ones((2, 3)), 14 | np.matrix([[ 1., 1., 1.], 15 | [ 1., 1., 1.]])) 16 | 17 | assert_array_equal(numpy.matlib.ones(2), np.matrix([[ 1., 1.]])) 18 | 19 | def test_zeros(): 20 | assert_array_equal(numpy.matlib.zeros((2, 3)), 21 | np.matrix([[ 0., 0., 0.], 22 | [ 0., 0., 0.]])) 23 | 24 | assert_array_equal(numpy.matlib.zeros(2), np.matrix([[ 0., 0.]])) 25 | 26 | def test_identity(): 27 | x = numpy.matlib.identity(2, dtype=np.int) 28 | assert_array_equal(x, np.matrix([[1, 0], [0, 1]])) 29 | 30 | def test_eye(): 31 | x = numpy.matlib.eye(3, k=1, dtype=int) 32 | assert_array_equal(x, np.matrix([[ 0, 1, 0], 33 | [ 0, 0, 1], 34 | [ 0, 0, 0]])) 35 | 36 | def test_rand(): 37 | x = numpy.matlib.rand(3) 38 | # check matrix type, array would have shape (3,) 39 | assert_(x.ndim == 2) 40 | 41 | def test_randn(): 42 | x = np.matlib.randn(3) 43 | # check matrix type, array would have shape (3,) 44 | assert_(x.ndim == 2) 45 | 46 | def test_repmat(): 47 | a1 = np.arange(4) 48 | x = numpy.matlib.repmat(a1, 2, 2) 49 | y = np.array([[0, 1, 2, 3, 0, 1, 2, 3], 50 | [0, 1, 2, 3, 0, 1, 2, 3]]) 51 | assert_array_equal(x, y) 52 | 53 | 54 | if __name__ == "__main__": 55 | run_module_suite() 56 | -------------------------------------------------------------------------------- /dist/numpy/tests/test_matlib.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/tests/test_matlib.pyc -------------------------------------------------------------------------------- /dist/numpy/tests/test_numpy_version.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import re 4 | 5 | import numpy as np 6 | from numpy.testing import assert_, run_module_suite 7 | 8 | 9 | def test_valid_numpy_version(): 10 | # Verify that the numpy version is a valid one (no .post suffix or other 11 | # nonsense). See gh-6431 for an issue caused by an invalid version. 12 | version_pattern = r"^[0-9]+\.[0-9]+\.[0-9]+(|a[0-9]|b[0-9]|rc[0-9])" 13 | dev_suffix = r"(\.dev0\+([0-9a-f]{7}|Unknown))" 14 | if np.version.release: 15 | res = re.match(version_pattern, np.__version__) 16 | else: 17 | res = re.match(version_pattern + dev_suffix, np.__version__) 18 | 19 | assert_(res is not None, np.__version__) 20 | 21 | 22 | if __name__ == "__main__": 23 | run_module_suite() 24 | -------------------------------------------------------------------------------- /dist/numpy/tests/test_numpy_version.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/tests/test_numpy_version.pyc -------------------------------------------------------------------------------- /dist/numpy/tests/test_reloading.py: -------------------------------------------------------------------------------- 1 | from __future__ import division, absolute_import, print_function 2 | 3 | import sys 4 | 5 | from numpy.testing import assert_raises, assert_, run_module_suite 6 | 7 | if sys.version_info[:2] >= (3, 4): 8 | from importlib import reload 9 | else: 10 | from imp import reload 11 | 12 | def test_numpy_reloading(): 13 | # gh-7844. Also check that relevant globals retain their identity. 14 | import numpy as np 15 | import numpy._globals 16 | 17 | _NoValue = np._NoValue 18 | VisibleDeprecationWarning = np.VisibleDeprecationWarning 19 | ModuleDeprecationWarning = np.ModuleDeprecationWarning 20 | 21 | reload(np) 22 | assert_(_NoValue is np._NoValue) 23 | assert_(ModuleDeprecationWarning is np.ModuleDeprecationWarning) 24 | assert_(VisibleDeprecationWarning is np.VisibleDeprecationWarning) 25 | 26 | assert_raises(RuntimeError, reload, numpy._globals) 27 | reload(np) 28 | assert_(_NoValue is np._NoValue) 29 | assert_(ModuleDeprecationWarning is np.ModuleDeprecationWarning) 30 | assert_(VisibleDeprecationWarning is np.VisibleDeprecationWarning) 31 | 32 | 33 | if __name__ == "__main__": 34 | run_module_suite() 35 | -------------------------------------------------------------------------------- /dist/numpy/tests/test_reloading.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/tests/test_reloading.pyc -------------------------------------------------------------------------------- /dist/numpy/tests/test_scripts.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/tests/test_scripts.pyc -------------------------------------------------------------------------------- /dist/numpy/version.py: -------------------------------------------------------------------------------- 1 | 2 | # THIS FILE IS GENERATED FROM NUMPY SETUP.PY 3 | # 4 | # To compare versions robustly, use `numpy.lib.NumpyVersion` 5 | short_version = '1.11.2' 6 | version = '1.11.2' 7 | full_version = '1.11.2' 8 | git_revision = '' 9 | release = True 10 | 11 | if not release: 12 | version = full_version 13 | -------------------------------------------------------------------------------- /dist/numpy/version.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rlhotovy/lambda-numba/4f35495c668637505cb5e4f04284333f719273d2/dist/numpy/version.pyc -------------------------------------------------------------------------------- /docker/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM continuumio/conda_builder_linux 2 | 3 | ENV PATH /opt/miniconda/bin:$PATH 4 | 5 | RUN conda install numpy 6 | RUN conda install numba 7 | 8 | CMD bash 9 | -------------------------------------------------------------------------------- /src/kernels.py: -------------------------------------------------------------------------------- 1 | import os 2 | import numpy as np 3 | from numba.pycc import CC 4 | 5 | cc = CC('kernels') 6 | 7 | output_dir = '{}/dist'.format(os.path.abspath('..')) 8 | cc.output_dir = output_dir 9 | 10 | 11 | @cc.export('square', 'f8(f8)') 12 | def square(x): 13 | return x ** 2 14 | 15 | 16 | @cc.export('squarearr', 'f8[:](f8[:])') 17 | def square_array(arr): 18 | return np.square(arr) 19 | 20 | 21 | cc.compile() 22 | --------------------------------------------------------------------------------