def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('ellippy',parent_package, top_path)
config.add_extension('ellip_fort', sources=['ellip.pyf','ellip.f'])
config.add_extension('direct_fort', sources=['direct.pyf','direct.f'])
config.add_data_files('ELCOR.dat')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('statsmodels', parent_package, top_path)
# these are subpackages because they have Cython code
config.add_subpackage('nonparametric')
config.add_subpackage('tsa')
#TODO: delegate the non-test stuff to subpackages
config.add_data_files('sandbox/panel/test_data.txt')
curdir = os.path.abspath(os.path.dirname(__file__))
extradatafiles = [os.path.relpath(os.path.join(r,d),start=curdir)
for r,ds,f in os.walk(os.path.join(curdir, 'datasets'))
for d in f if not os.path.splitext(d)[1] in
['.py', '.pyc']]
for f in extradatafiles:
config.add_data_files(f)
# add all the test and results directories for non *.py files
for root, dirnames, filenames in os.walk(curdir):
for dir_name in dirnames:
if dir_name in ['tests', 'results'] and root != 'sandbox':
config.add_data_dir(os.path.relpath(
os.path.join(root, dir_name),
start = curdir)
)
return config
def configuration(parent_package="", top_path=None):
from numpy.distutils.misc_util import Configuration, get_mathlibs
config = Configuration("random", parent_package, top_path)
def generate_libraries(ext, build_dir):
config_cmd = config.get_config_cmd()
if top_path is None:
libs = get_mathlibs()
else:
path = join(split(build_dir)[0], "core")
libs = get_mathlibs(path)
tc = testcode_wincrypt()
if config_cmd.try_run(tc):
libs.append("Advapi32")
ext.libraries.extend(libs)
return None
libs = []
# Configure mtrand
config.add_extension(
"mtrand",
sources=[join("mtrand", x) for x in ["mtrand.c", "randomkit.c", "initarray.c", "distributions.c"]]
+ [generate_libraries],
libraries=libs,
depends=[join("mtrand", "*.h"), join("mtrand", "*.pyx"), join("mtrand", "*.pxi")],
)
config.add_data_files((".", join("mtrand", "randomkit.h")))
config.add_data_dir("tests")
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('impl', parent_package, top_path)
randomdir = os.path.join(top_path, "lightning", "impl", "randomkit")
config.add_extension('adagrad_fast',
sources=['adagrad_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('dataset_fast',
sources=['dataset_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('dual_cd_fast',
sources=['dual_cd_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('loss_fast',
sources=['loss_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('prank_fast',
sources=['prank_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('primal_cd_fast',
sources=['primal_cd_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('prox_fast',
sources=['prox_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('sag_fast',
sources=['sag_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('sdca_fast',
sources=['sdca_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('sgd_fast',
sources=['sgd_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('svrg_fast',
sources=['svrg_fast.cpp'],
include_dirs=[numpy.get_include(), randomdir])
config.add_subpackage('datasets')
config.add_subpackage('randomkit')
config.add_subpackage('tests')
# add .pxd files to be re-used by third party software
config.add_data_files('sag_fast.pxd', 'dataset_fast.pxd',
'sgd_fast.pxd', 'prox_fast.pxd')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('',parent_package,top_path)
config.add_subpackage('holopy')
config.add_subpackage('holopy.core')
config.add_subpackage('holopy.core.process')
config.add_subpackage('holopy.core.io')
config.add_subpackage('holopy.core.third_party')
config.add_subpackage('holopy.core.tests')
config.add_subpackage('holopy.propagation')
config.add_subpackage('holopy.propagation.tests')
config.add_subpackage('holopy.scattering')
config.add_subpackage('holopy.scattering.theory')
config.add_subpackage('holopy.scattering.theory.mie_f')
config.add_subpackage('holopy.scattering.scatterer')
config.add_subpackage('holopy.scattering.tests')
config.add_subpackage('holopy.scattering.third_party')
config.add_subpackage('holopy.fitting')
config.add_subpackage('holopy.fitting.tests')
config.add_subpackage('holopy.fitting.third_party')
config.add_subpackage('holopy.vis')
config.add_data_files(['.',['AUTHORS']])
config.add_data_files('holopy/propagation/tests/gold/*.yaml')
config.add_data_files('holopy/scattering/tests/gold/*.yaml')
config.add_data_files('holopy/core/tests/exampledata/*.yaml')
config.add_data_files('holopy/core/tests/exampledata/*.npy')
config.get_version()
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs
config = Configuration('io', parent_package, top_path)
config.add_data_dir('tests')
config.add_data_files('_plugins/*.ini')
# This function tries to create C files from the given .pyx files. If
# it fails, we build the checked-in .c files.
cython(['_plugins/_colormixer.pyx', '_plugins/_histograms.pyx'],
working_path=base_path)
config.add_extension('_plugins._colormixer',
sources=['_plugins/_colormixer.c'],
include_dirs=[get_numpy_include_dirs()])
config.add_extension('_plugins._histograms',
sources=['_plugins/_histograms.c'],
include_dirs=[get_numpy_include_dirs()])
config.add_extension('_plugins._tifffile',
sources=['_plugins/tifffile.c'],
include_dirs=[get_numpy_include_dirs()])
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('lib',parent_package,top_path)
config.add_subpackage('parser')
config.add_data_files('*.txt','parser/*.txt')
config.add_data_dir('src')
return config
def configuration(parent_package='',top_path=None):
config = Configuration('f2py', parent_package, top_path)
config.add_data_dir('tests')
config.add_data_files('src/fortranobject.c',
'src/fortranobject.h',
)
config.make_svn_version_py()
def generate_f2py_py(build_dir):
f2py_exe = 'f2py'+os.path.basename(sys.executable)[6:]
if f2py_exe[-4:]=='.exe':
f2py_exe = f2py_exe[:-4] + '.py'
if 'bdist_wininst' in sys.argv and f2py_exe[-3:] != '.py':
f2py_exe = f2py_exe + '.py'
target = os.path.join(build_dir, f2py_exe)
if newer(__file__, target):
log.info('Creating %s', target)
f = open(target, 'w')
f.write('#!%s\n' % (sys.executable))
mainloc = os.path.join(os.path.dirname(__file__), "__main__.py")
with open(mainloc) as mf:
f.write(mf.read())
f.close()
return target
config.add_scripts(generate_f2py_py)
log.info('F2PY Version %s', config.get_version())
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration(None, parent_package, top_path)
config.add_subpackage('libtiff')
config.get_version('libtiff/version.py')
config.add_data_files(('libtiff', 'LICENSE'))
return config
def configuration(parent_package='',top_path=None):
config = Configuration('f2py', parent_package, top_path)
config.add_subpackage('lib')
config.add_data_dir('docs')
config.add_data_files('src/fortranobject.c',
'src/fortranobject.h',
'f2py.1'
)
config.make_svn_version_py()
def generate_f2py_py(build_dir):
f2py_exe = 'f2py'+os.path.basename(sys.executable)[6:]
if f2py_exe[-4:]=='.exe':
f2py_exe = f2py_exe[:-4] + '.py'
if 'bdist_wininst' in sys.argv and f2py_exe[-3:] != '.py':
f2py_exe = f2py_exe + '.py'
target = os.path.join(build_dir,f2py_exe)
if newer(__file__,target):
print 'Creating',target
f = open(target,'w')
f.write('''\
#!/usr/bin/env %s
# See http://cens.ioc.ee/projects/f2py2e/
import os, sys
for mode in ["g3-numpy", "2e-numeric", "2e-numarray", "2e-numpy"]:
try:
i=sys.argv.index("--"+mode)
del sys.argv[i]
break
except ValueError: pass
os.environ["NO_SCIPY_IMPORT"]="f2py"
if mode=="g3-numpy":
try:
from main import main
except ImportError:
from numpy.f2py.lib.api import main
elif mode=="2e-numeric":
from f2py2e import main
elif mode=="2e-numarray":
sys.argv.append("-DNUMARRAY")
from f2py2e import main
elif mode=="2e-numpy":
from numpy.f2py import main
else:
print >> sys.stderr, "Unknown mode:",`mode`
sys.exit(1)
main()
'''%(os.path.basename(sys.executable)))
f.close()
return target
config.add_scripts(generate_f2py_py)
print 'F2PY Version',config.get_version()
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration, get_mathlibs
config = Configuration('random',parent_package,top_path)
def generate_libraries(ext, build_dir):
config_cmd = config.get_config_cmd()
libs = get_mathlibs()
tc = testcode_wincrypt()
if config_cmd.try_run(tc):
libs.append('Advapi32')
ext.libraries.extend(libs)
return None
defs = []
if needs_mingw_ftime_workaround():
defs.append(("NPY_NEEDS_MINGW_TIME_WORKAROUND", None))
libs = ['Advapi32']
# Configure mtrand
config.add_extension('mtrand',
sources=[join('mtrand', x) for x in
['mtrand.c', 'randomkit.c', 'initarray.c',
'distributions.c']]+[generate_libraries],
libraries=libs,
depends = [join('mtrand','*.h'),
join('mtrand','*.pyx'),
join('mtrand','*.pxi'),
],
define_macros = defs,
)
config.add_data_files(('.', join('mtrand', 'randomkit.h')))
config.add_data_dir('tests')
return config
def configuration(parent_package='', top_path=None, package_name=DISTNAME):
if os.path.exists('MANIFEST'): os.remove('MANIFEST')
write_info(os.path.join("scikits", "talkbox", "info.py"))
write_version(os.path.join("scikits", "talkbox", "version.py"))
# XXX: find a way to include the doc in sdist
if os.path.exists(os.path.join("docs", "src")):
write_version(os.path.join("docs", "src", "talkbox_version.py"))
pkg_prefix_dir = os.path.join('scikits', 'talkbox')
from numpy.distutils.misc_util import Configuration
config = Configuration(None, parent_package, top_path,
namespace_packages = ['scikits'])
config.set_options(
ignore_setup_xxx_py=True,
assume_default_configuration=True,
delegate_options_to_subpackages=True,
quiet=True,
)
config.add_subpackage('scikits')
config.add_subpackage(DISTNAME)
config.add_data_files('scikits/__init__.py')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration, get_mathlibs
config = Configuration('random',parent_package,top_path)
def generate_libraries(ext, build_dir):
config_cmd = config.get_config_cmd()
libs = get_mathlibs()
tc = testcode_wincrypt()
if config_cmd.try_run(tc):
libs.append('Advapi32')
ext.libraries.extend(libs)
return None
# Configure mtrand
config.add_extension('mtrand',
sources=[join('mtrand', x) for x in
['mtrand.c', 'randomkit.c', 'initarray.c',
'distributions.c']
] + [generate_libraries],
depends = [join('mtrand','*.h'),
join('mtrand','*.pyx'),
join('mtrand','*.pxi'),
],
**get_info('ndarray'))
config.add_data_files(('.', join('mtrand', 'randomkit.h')))
config.add_data_dir('tests')
return config
def configuration(parent_package='', top_path=None,
package_name=NAME):
if os.path.exists('MANIFEST'):
os.remove('MANIFEST')
from numpy.distutils.misc_util import Configuration
config = Configuration(None, parent_package, top_path,
version = VERSION,
author = AUTHOR,
author_email = AUTHOR_EMAIL,
license = LICENSE,
url = URL,
download_url = DOWNLOAD_URL,
description = DESCRIPTION,
long_description = LONG_DESCRIPTION,
classifiers = CLASSIFIERS)
config.set_options(
ignore_setup_xxx_py = True,
assume_default_configuration = True,
delegate_options_to_subpackages = True,
quiet = True,
)
config.add_subpackage('scikits')
config.add_data_files('scikits/__init__.py')
config.add_subpackage(NAME)
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.system_info import get_info, NotFoundError
from numpy.distutils.misc_util import Configuration
from scipy._build_utils import get_g77_abi_wrappers, get_sgemv_fix
lapack_opt = get_info('lapack_opt')
if not lapack_opt:
raise NotFoundError('no lapack/blas resources found')
config = Configuration('arpack', parent_package, top_path)
arpack_sources = [join('ARPACK','SRC', '*.f')]
arpack_sources.extend([join('ARPACK','UTIL', '*.f')])
arpack_sources += get_g77_abi_wrappers(lapack_opt)
config.add_library('arpack_scipy', sources=arpack_sources,
include_dirs=[join('ARPACK', 'SRC')])
ext_sources = ['arpack.pyf.src']
ext_sources += get_sgemv_fix(lapack_opt)
config.add_extension('_arpack',
sources=ext_sources,
libraries=['arpack_scipy'],
extra_info=lapack_opt,
depends=arpack_sources,
)
config.add_data_dir('tests')
# Add license files
config.add_data_files('ARPACK/COPYING')
return config
def configuration(parent_package="", top_path=None):
from numpy.distutils.misc_util import Configuration
# Initialize
config = Configuration(None, parent_package=parent_package, top_path=top_path)
# Set options
config.set_options(
ignore_setup_xxx_py=True, assume_default_configuration=True, quiet=True, delegate_options_to_subpackages=True
)
# Add scripts
scripts = []
for pat in ["*.py", "*.bash", "*.sh"]:
pat = os.path.join("bin", pat)
scripts.extend(glob(pat))
config.add_scripts(*scripts)
# Add special files
config.add_data_files(("vacumm", ["LICENSE", "CHANGES.rst"]))
config.add_subpackage("vacumm", "lib/python/vacumm")
config.add_data_dir(("vacumm/vacumm-config", "config")) # not needed
config.add_data_dir(("vacumm/vacumm-data", "data")) # all data files
config.add_data_dir(("vacumm/vacumm-scripts/test", "scripts/test")) # test scripts
config.add_data_dir(("vacumm/vacumm-scripts/tutorials", "scripts/tutorials")) # tutorials
config.add_data_dir(("vacumm/vacumm-scripts/courses", "scripts/courses")) # courses
return config
def configuration(parent_package="", top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration("statsmodels", parent_package, top_path)
# these are subpackages because they have Cython code
config.add_subpackage("nonparametric")
config.add_subpackage("tsa")
# TODO: delegate the non-test stuff to subpackages
config.add_data_files("sandbox/panel/test_data.txt")
config.add_data_files("stats/libqsturng/tests/bootleg.dat")
config.add_data_files("stats/libqsturng/CH.r")
config.add_data_files("stats/libqsturng/LICENSE.txt")
curdir = os.path.abspath(os.path.dirname(__file__))
extradatafiles = [
relpath(os.path.join(r, d), start=curdir)
for r, ds, f in os.walk(os.path.join(curdir, "datasets"))
for d in f
if not os.path.splitext(d)[1] in [".py", ".pyc"]
]
for f in extradatafiles:
config.add_data_files(f)
# add all the test and results directories for non *.py files
for root, dirnames, filenames in os.walk(curdir):
for dir_name in dirnames:
if dir_name in ["tests", "results"] and root != "sandbox":
config.add_data_dir(relpath(os.path.join(root, dir_name), start=curdir))
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('scipy',parent_package,top_path)
config.add_subpackage('cluster')
config.add_subpackage('constants')
config.add_subpackage('fftpack')
config.add_subpackage('integrate')
config.add_subpackage('interpolate')
config.add_subpackage('io')
config.add_subpackage('linalg')
config.add_data_files('*.pxd')
config.add_subpackage('misc')
config.add_subpackage('odr')
config.add_subpackage('optimize')
config.add_subpackage('signal')
config.add_subpackage('sparse')
config.add_subpackage('spatial')
config.add_subpackage('special')
config.add_subpackage('stats')
config.add_subpackage('ndimage')
if sys.version_info[0] < 3:
config.add_subpackage('weave')
config.add_subpackage('_build_utils')
config.add_subpackage('_lib')
config.make_config_py()
return config
def configuration(parent_package='', top_path=None):
config = Configuration('f2py', parent_package, top_path)
config.add_data_dir('tests')
config.add_data_files(
'src/fortranobject.c',
'src/fortranobject.h')
return config
def configuration(parent_package='',top_path=None):
from scipy._build_utils.system_info import get_info, NotFoundError
lapack_opt = get_info("lapack_opt")
from numpy.distutils.misc_util import Configuration
config = Configuration('scipy',parent_package,top_path)
config.add_subpackage('cluster')
config.add_subpackage('constants')
config.add_subpackage('fftpack')
config.add_subpackage('integrate')
config.add_subpackage('interpolate')
config.add_subpackage('io')
config.add_subpackage('linalg')
config.add_data_files('*.pxd')
config.add_subpackage('misc')
config.add_subpackage('odr')
config.add_subpackage('optimize')
config.add_subpackage('signal')
config.add_subpackage('sparse')
config.add_subpackage('spatial')
config.add_subpackage('special')
config.add_subpackage('stats')
config.add_subpackage('ndimage')
config.add_subpackage('_build_utils')
config.add_subpackage('_lib')
config.make_config_py()
return config
def configuration(parent_package="", top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration("pyOpt", parent_package, top_path)
# need: auto add_subpackage from source availability
config.add_subpackage("pyALHSO")
config.add_subpackage("pyALPSO")
config.add_subpackage("pyCOBYLA")
config.add_subpackage("pyCONMIN")
config.add_subpackage("pyFSQP")
config.add_subpackage("pyGCMMA")
config.add_subpackage("pyKSOPT")
config.add_subpackage("pyMIDACO")
config.add_subpackage("pyMMA")
config.add_subpackage("pyMMFD")
# config.add_subpackage('pyNEWSUMT')
config.add_subpackage("pyNLPQL")
# config.add_subpackage('pyNSGA2')
config.add_subpackage("pyPSQP")
config.add_subpackage("pySLSQP")
config.add_subpackage("pySNOPT")
config.add_subpackage("pySOLVOPT")
config.add_subpackage("pyIPOPT")
# config.add_subpackage('pyVMACO')
config.add_data_files("LICENSE", "README")
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from scipy._build_utils.system_info import get_info, NotFoundError, numpy_info
from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs
from scipy._build_utils import (get_g77_abi_wrappers, split_fortran_files)
lapack_opt = get_info('lapack_opt')
if not lapack_opt:
msg = 'No lapack/blas resources found.'
if sys.platform == "darwin":
msg = ('No lapack/blas resources found. '
'Note: Accelerate is no longer supported.')
raise NotFoundError(msg)
config = Configuration(None, parent_package, top_path)
config.set_options(ignore_setup_xxx_py=True,
assume_default_configuration=True,
delegate_options_to_subpackages=True,
quiet=True)
config.add_subpackage('scipy')
config.add_data_files(('scipy', '*.txt'))
config.get_version('scipy/version.py')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('SwiftTemp', parent_package, top_path)
config.add_data_files('SNIa_m2_template_fe.dat','SNIa_w1_template_fe.dat',
'SNIa_w2_template_fe.dat')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('grid', parent_package, top_path)
config.add_extension('_interp_', sources=['interp.f90'])
config.add_data_files('Makefile')
config.add_data_files('vacumm.cfg')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('pyOpt',parent_package,top_path)
# need: auto add_subpackage from source availability
config.add_subpackage('pyALGENCAN')
config.add_subpackage('pyALHSO')
config.add_subpackage('pyALPSO')
config.add_subpackage('pyCOBYLA')
config.add_subpackage('pyCONMIN')
config.add_subpackage('pyFILTERSD')
config.add_subpackage('pyFSQP')
config.add_subpackage('pyGCMMA')
#config.add_subpackage('pyIPOPT')
config.add_subpackage('pyKSOPT')
config.add_subpackage('pyMIDACO')
config.add_subpackage('pyMMA')
config.add_subpackage('pyMMFD')
config.add_subpackage('pyNLPQL')
config.add_subpackage('pyNLPQLP')
config.add_subpackage('pyNSGA2')
config.add_subpackage('pyPSQP')
config.add_subpackage('pySDPEN')
config.add_subpackage('pySLSQP')
config.add_subpackage('pySNOPT')
config.add_subpackage('pySOLVOPT')
config.add_data_files('LICENSE','README')
return config
def configuration(parent_package='core', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('refdata', parent_package, top_path)
config.add_data_files('*.json')
config.add_data_files('*.yaml')
config.add_data_dir('tests')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('_lib', parent_package, top_path)
config.add_data_files('tests/*.py')
return config
def configuration(parent_package="", top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration("misc", parent_package, top_path)
config.add_data_files("lena.dat")
config.add_data_dir("tests")
return config
def configuration(parent_package='', top_path=None, package_name=DISTNAME):
if os.path.exists('MANIFEST'):
os.remove('MANIFEST')
from numpy.distutils.misc_util import Configuration
config = Configuration(None, parent_package, top_path,
namespace_packages = ['scikits'])
config.add_subpackage('scikits')
config.add_subpackage(DISTNAME)
config.add_subpackage('scikits.statsmodels')
config.add_data_files('scikits/__init__.py')
config.add_data_files('docs/build/htmlhelp/statsmodelsdoc.chm',
'statsmodels/statsmodelsdoc.chm')
if compile_cython:
config.add_extension('tsa/kalmanf/kalman_loglike',
sources = ['statsmodels/tsa/kalmanf/kalman_loglike.c'],
include_dirs=[numpy.get_include()])
config.set_options(
ignore_setup_xxx_py = True,
assume_default_configuration = True,
delegate_options_to_subpackages = True,
quiet = False,
)
return config
def configuration(parent_package='',top_path=None, package_name=DISTNAME):
if os.path.exists('MANIFEST'): os.remove('MANIFEST')
pkg_prefix_dir = os.path.join('scikits', 'samplerate')
write_version(os.path.join("scikits", "samplerate", "version.py"))
if os.path.exists(os.path.join("docs", "src")):
write_version(os.path.join("docs", "src", "samplerate_version.py"))
write_info(os.path.join("scikits", "samplerate", "info.py"))
from numpy.distutils.misc_util import Configuration
config = Configuration(None,parent_package,top_path,
namespace_packages=['scikits'],
version=VERSION,
maintainer=MAINTAINER,
maintainer_email=MAINTAINER_EMAIL,
description=DESCRIPTION,
long_description=LONG_DESCRIPTION,
url=URL,
download_url=DOWNLOAD_URL,
license=LICENSE)
config.set_options(
ignore_setup_xxx_py=True,
assume_default_configuration=True,
delegate_options_to_subpackages=True,
quiet=True,
)
config.add_subpackage('scikits')
config.add_data_files('scikits/__init__.py')
config.add_subpackage(DISTNAME)
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
from scipy._build_utils.system_info import get_info as get_system_info
from scipy._build_utils import combine_dict, uses_blas64
config = Configuration('special', parent_package, top_path)
if uses_blas64():
lapack_opt = get_system_info('lapack_ilp64_opt')
else:
lapack_opt = get_system_info('lapack_opt')
define_macros = []
if sys.platform == 'win32':
# define_macros.append(('NOINFINITIES',None))
# define_macros.append(('NONANS',None))
define_macros.append(('_USE_MATH_DEFINES',None))
curdir = os.path.abspath(os.path.dirname(__file__))
python_inc_dirs = get_python_inc()
plat_specific_python_inc_dirs = get_python_inc(plat_specific=1)
inc_dirs = [get_numpy_include_dirs(), python_inc_dirs]
if python_inc_dirs != plat_specific_python_inc_dirs:
inc_dirs.append(plat_specific_python_inc_dirs)
inc_dirs.append(join(dirname(dirname(__file__)), '_lib'))
inc_dirs.append(join(dirname(dirname(__file__)), '_build_utils', 'src'))
# C libraries
cephes_src = [join('cephes','*.c')]
cephes_hdr = [join('cephes', '*.h')]
config.add_library('sc_cephes',sources=cephes_src,
include_dirs=[curdir] + inc_dirs,
depends=(cephes_hdr + ['*.h']),
macros=define_macros)
# Fortran/C++ libraries
mach_src = [join('mach','*.f')]
amos_src = [join('amos','*.f')]
cdf_src = [join('cdflib','*.f')]
specfun_src = [join('specfun','*.f')]
config.add_library('sc_mach',sources=mach_src,
config_fc={'noopt':(__file__,1)})
config.add_library('sc_amos',sources=amos_src)
config.add_library('sc_cdf',sources=cdf_src)
config.add_library('sc_specfun',sources=specfun_src)
# Extension specfun
config.add_extension('specfun',
sources=['specfun.pyf'],
f2py_options=['--no-wrap-functions'],
depends=specfun_src,
define_macros=[],
libraries=['sc_specfun'])
# Extension _ufuncs
headers = ['*.h', join('cephes', '*.h')]
ufuncs_src = ['_ufuncs.c', 'sf_error.c',
'amos_wrappers.c', 'cdf_wrappers.c', 'specfun_wrappers.c',
'_cosine.c']
ufuncs_dep = (
headers
+ ufuncs_src
+ amos_src
+ cephes_src
+ mach_src
+ cdf_src
+ specfun_src
)
cfg = combine_dict(lapack_opt,
include_dirs=[curdir] + inc_dirs + [numpy.get_include()],
libraries=['sc_amos', 'sc_cephes', 'sc_mach',
'sc_cdf', 'sc_specfun'],
define_macros=define_macros)
_ufuncs = config.add_extension('_ufuncs',
depends=ufuncs_dep,
sources=ufuncs_src,
extra_info=get_info("npymath"),
**cfg)
_ufuncs._pre_build_hook = set_c_flags_hook
# Extension _ufuncs_cxx
ufuncs_cxx_src = ['_ufuncs_cxx.cxx', 'sf_error.c',
'_faddeeva.cxx', 'Faddeeva.cc',
'_wright.cxx', 'wright.cc']
ufuncs_cxx_dep = (headers + ufuncs_cxx_src + cephes_src
+ ['*.hh'])
config.add_extension('_ufuncs_cxx',
sources=ufuncs_cxx_src,
depends=ufuncs_cxx_dep,
include_dirs=[curdir] + inc_dirs,
define_macros=define_macros,
extra_info=get_info("npymath"))
cfg = combine_dict(lapack_opt, include_dirs=inc_dirs)
config.add_extension('_ellip_harm_2',
sources=['_ellip_harm_2.c', 'sf_error.c',],
**cfg)
# Cython API
config.add_data_files('cython_special.pxd')
cython_special_src = ['cython_special.c', 'sf_error.c',
'amos_wrappers.c', 'cdf_wrappers.c',
'specfun_wrappers.c', '_cosine.c']
cython_special_dep = (
headers
+ ufuncs_src
+ ufuncs_cxx_src
+ amos_src
+ cephes_src
+ mach_src
+ cdf_src
+ specfun_src
)
cfg = combine_dict(lapack_opt,
include_dirs=[curdir] + inc_dirs + [numpy.get_include()],
libraries=['sc_amos', 'sc_cephes', 'sc_mach',
'sc_cdf', 'sc_specfun'],
define_macros=define_macros)
cython_special = config.add_extension('cython_special',
depends=cython_special_dep,
sources=cython_special_src,
extra_info=get_info("npymath"),
**cfg)
cython_special._pre_build_hook = set_c_flags_hook
# combinatorics
config.add_extension('_comb',
sources=['_comb.c'])
# testing for _round.h
config.add_extension('_test_round',
sources=['_test_round.c'],
depends=['_round.h', 'cephes/dd_idefs.h'],
include_dirs=[numpy.get_include()] + inc_dirs,
extra_info=get_info('npymath'))
config.add_data_files('tests/*.py')
config.add_data_files('tests/data/README')
# regenerate npz data files
makenpz = os.path.join(os.path.dirname(__file__),
'utils', 'makenpz.py')
data_dir = os.path.join(os.path.dirname(__file__),
'tests', 'data')
for name in ['boost', 'gsl', 'local']:
subprocess.check_call([sys.executable, makenpz,
'--use-timestamp',
os.path.join(data_dir, name)])
config.add_data_files('tests/data/*.npz')
config.add_subpackage('_precompute')
# Type stubs
config.add_data_files('*.pyi')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, dot_join
from numpy.distutils.system_info import get_info, default_lib_dirs
config = Configuration('core', parent_package, top_path)
local_dir = config.local_path
codegen_dir = join(local_dir, 'code_generators')
if is_released(config):
warnings.simplefilter('error', MismatchCAPIWarning)
# Check whether we have a mismatch between the set C API VERSION and the
# actual C API VERSION
check_api_version(C_API_VERSION, codegen_dir)
generate_umath_py = join(codegen_dir, 'generate_umath.py')
n = dot_join(config.name, 'generate_umath')
generate_umath = imp.load_module('_'.join(n.split('.')),
open(generate_umath_py, 'U'),
generate_umath_py, ('.py', 'U', 1))
header_dir = 'include/numpy' # this is relative to config.path_in_package
cocache = CallOnceOnly()
def generate_config_h(ext, build_dir):
target = join(build_dir, header_dir, 'config.h')
d = os.path.dirname(target)
if not os.path.exists(d):
os.makedirs(d)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
# Check sizeof
moredefs, ignored = cocache.check_types(config_cmd, ext, build_dir)
# Check math library and C99 math funcs availability
mathlibs = check_mathlib(config_cmd)
moredefs.append(('MATHLIB', ','.join(mathlibs)))
check_math_capabilities(config_cmd, moredefs, mathlibs)
moredefs.extend(cocache.check_ieee_macros(config_cmd)[0])
moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[0])
# Signal check
if is_npy_no_signal():
moredefs.append('__NPY_PRIVATE_NO_SIGNAL')
# Windows checks
if sys.platform == 'win32' or os.name == 'nt':
win32_checks(moredefs)
# Inline check
inline = config_cmd.check_inline()
# Check whether we need our own wide character support
if not config_cmd.check_decl('Py_UNICODE_WIDE',
headers=['Python.h']):
PYTHON_HAS_UNICODE_WIDE = True
else:
PYTHON_HAS_UNICODE_WIDE = False
if ENABLE_SEPARATE_COMPILATION:
moredefs.append(('ENABLE_SEPARATE_COMPILATION', 1))
if NPY_RELAXED_STRIDES_CHECKING:
moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
# Get long double representation
if sys.platform != 'darwin':
rep = check_long_double_representation(config_cmd)
if rep in [
'INTEL_EXTENDED_12_BYTES_LE',
'INTEL_EXTENDED_16_BYTES_LE',
'MOTOROLA_EXTENDED_12_BYTES_BE', 'IEEE_QUAD_LE',
'IEEE_QUAD_BE', 'IEEE_DOUBLE_LE', 'IEEE_DOUBLE_BE',
'DOUBLE_DOUBLE_BE', 'DOUBLE_DOUBLE_LE'
]:
moredefs.append(('HAVE_LDOUBLE_%s' % rep, 1))
else:
raise ValueError("Unrecognized long double format: %s" %
rep)
# Py3K check
if sys.version_info[0] == 3:
moredefs.append(('NPY_PY3K', 1))
# Generate the config.h file from moredefs
target_f = open(target, 'w')
for d in moredefs:
if isinstance(d, str):
target_f.write('#define %s\n' % (d))
else:
target_f.write('#define %s %s\n' % (d[0], d[1]))
# define inline to our keyword, or nothing
target_f.write('#ifndef __cplusplus\n')
if inline == 'inline':
target_f.write('/* #undef inline */\n')
else:
target_f.write('#define inline %s\n' % inline)
target_f.write('#endif\n')
# add the guard to make sure config.h is never included directly,
# but always through npy_config.h
target_f.write("""
#ifndef _NPY_NPY_CONFIG_H_
#error config.h should never be included directly, include npy_config.h instead
#endif
""")
target_f.close()
print('File:', target)
target_f = open(target)
print(target_f.read())
target_f.close()
print('EOF')
else:
mathlibs = []
target_f = open(target)
for line in target_f:
s = '#define MATHLIB'
if line.startswith(s):
value = line[len(s):].strip()
if value:
mathlibs.extend(value.split(','))
target_f.close()
# Ugly: this can be called within a library and not an extension,
# in which case there is no libraries attributes (and none is
# needed).
if hasattr(ext, 'libraries'):
ext.libraries.extend(mathlibs)
incl_dir = os.path.dirname(target)
if incl_dir not in config.numpy_include_dirs:
config.numpy_include_dirs.append(incl_dir)
return target
def generate_numpyconfig_h(ext, build_dir):
"""Depends on config.h: generate_config_h has to be called before !"""
# put private include directory in build_dir on search path
# allows using code generation in headers headers
config.add_include_dirs(join(build_dir, "src", "private"))
target = join(build_dir, header_dir, '_numpyconfig.h')
d = os.path.dirname(target)
if not os.path.exists(d):
os.makedirs(d)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
# Check sizeof
ignored, moredefs = cocache.check_types(config_cmd, ext, build_dir)
if is_npy_no_signal():
moredefs.append(('NPY_NO_SIGNAL', 1))
if is_npy_no_smp():
moredefs.append(('NPY_NO_SMP', 1))
else:
moredefs.append(('NPY_NO_SMP', 0))
mathlibs = check_mathlib(config_cmd)
moredefs.extend(cocache.check_ieee_macros(config_cmd)[1])
moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[1])
if ENABLE_SEPARATE_COMPILATION:
moredefs.append(('NPY_ENABLE_SEPARATE_COMPILATION', 1))
if NPY_RELAXED_STRIDES_CHECKING:
moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
# Check wether we can use inttypes (C99) formats
if config_cmd.check_decl('PRIdPTR', headers=['inttypes.h']):
moredefs.append(('NPY_USE_C99_FORMATS', 1))
# visibility check
hidden_visibility = visibility_define(config_cmd)
moredefs.append(('NPY_VISIBILITY_HIDDEN', hidden_visibility))
# Add the C API/ABI versions
moredefs.append(('NPY_ABI_VERSION', '0x%.8X' % C_ABI_VERSION))
moredefs.append(('NPY_API_VERSION', '0x%.8X' % C_API_VERSION))
# Add moredefs to header
target_f = open(target, 'w')
for d in moredefs:
if isinstance(d, str):
target_f.write('#define %s\n' % (d))
else:
target_f.write('#define %s %s\n' % (d[0], d[1]))
# Define __STDC_FORMAT_MACROS
target_f.write("""
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS 1
#endif
""")
target_f.close()
# Dump the numpyconfig.h header to stdout
print('File: %s' % target)
target_f = open(target)
print(target_f.read())
target_f.close()
print('EOF')
config.add_data_files((header_dir, target))
return target
def generate_api_func(module_name):
def generate_api(ext, build_dir):
script = join(codegen_dir, module_name + '.py')
sys.path.insert(0, codegen_dir)
try:
m = __import__(module_name)
log.info('executing %s', script)
h_file, c_file, doc_file = m.generate_api(
os.path.join(build_dir, header_dir))
finally:
del sys.path[0]
config.add_data_files((header_dir, h_file), (header_dir, doc_file))
return (h_file, )
return generate_api
generate_numpy_api = generate_api_func('generate_numpy_api')
generate_ufunc_api = generate_api_func('generate_ufunc_api')
config.add_include_dirs(join(local_dir, "src", "private"))
config.add_include_dirs(join(local_dir, "src"))
config.add_include_dirs(join(local_dir))
config.add_data_files('include/numpy/*.h')
config.add_include_dirs(join('src', 'npymath'))
config.add_include_dirs(join('src', 'multiarray'))
config.add_include_dirs(join('src', 'umath'))
config.add_include_dirs(join('src', 'npysort'))
config.add_define_macros([("HAVE_NPY_CONFIG_H", "1")])
config.add_define_macros([("_FILE_OFFSET_BITS", "64")])
config.add_define_macros([('_LARGEFILE_SOURCE', '1')])
config.add_define_macros([('_LARGEFILE64_SOURCE', '1')])
config.numpy_include_dirs.extend(config.paths('include'))
deps = [
join('src', 'npymath', '_signbit.c'),
join('include', 'numpy', '*object.h'),
'include/numpy/fenv/fenv.c',
'include/numpy/fenv/fenv.h',
join(codegen_dir, 'genapi.py'),
]
# Don't install fenv unless we need them.
if sys.platform == 'cygwin':
config.add_data_dir('include/numpy/fenv')
#######################################################################
# dummy module #
#######################################################################
# npymath needs the config.h and numpyconfig.h files to be generated, but
# build_clib cannot handle generate_config_h and generate_numpyconfig_h
# (don't ask). Because clib are generated before extensions, we have to
# explicitly add an extension which has generate_config_h and
# generate_numpyconfig_h as sources *before* adding npymath.
config.add_extension('_dummy',
sources=[
join('src', 'dummymodule.c'), generate_config_h,
generate_numpyconfig_h, generate_numpy_api
])
#######################################################################
# npymath library #
#######################################################################
subst_dict = dict([("sep", os.path.sep), ("pkgname", "numpy.core")])
def get_mathlib_info(*args):
# Another ugly hack: the mathlib info is known once build_src is run,
# but we cannot use add_installed_pkg_config here either, so we only
# update the substition dictionary during npymath build
config_cmd = config.get_config_cmd()
# Check that the toolchain works, to fail early if it doesn't
# (avoid late errors with MATHLIB which are confusing if the
# compiler does not work).
st = config_cmd.try_link('int main(void) { return 0;}')
if not st:
raise RuntimeError(
"Broken toolchain: cannot link a simple C program")
mlibs = check_mathlib(config_cmd)
posix_mlib = ' '.join(['-l%s' % l for l in mlibs])
msvc_mlib = ' '.join(['%s.lib' % l for l in mlibs])
subst_dict["posix_mathlib"] = posix_mlib
subst_dict["msvc_mathlib"] = msvc_mlib
npymath_sources = [
join('src', 'npymath', 'npy_math.c.src'),
join('src', 'npymath', 'ieee754.c.src'),
join('src', 'npymath', 'npy_math_complex.c.src'),
join('src', 'npymath', 'halffloat.c')
]
config.add_installed_library('npymath',
sources=npymath_sources + [get_mathlib_info],
install_dir='lib')
config.add_npy_pkg_config("npymath.ini.in", "lib/npy-pkg-config",
subst_dict)
config.add_npy_pkg_config("mlib.ini.in", "lib/npy-pkg-config", subst_dict)
#######################################################################
# npysort library #
#######################################################################
# This library is created for the build but it is not installed
npysort_sources = [
join('src', 'npysort', 'quicksort.c.src'),
join('src', 'npysort', 'mergesort.c.src'),
join('src', 'npysort', 'heapsort.c.src'),
join('src', 'private', 'npy_partition.h.src'),
join('src', 'npysort', 'selection.c.src'),
join('src', 'private', 'npy_binsearch.h.src'),
join('src', 'npysort', 'binsearch.c.src'),
]
config.add_library('npysort', sources=npysort_sources, include_dirs=[])
#######################################################################
# multiarray module #
#######################################################################
# Multiarray version: this function is needed to build foo.c from foo.c.src
# when foo.c is included in another file and as such not in the src
# argument of build_ext command
def generate_multiarray_templated_sources(ext, build_dir):
from numpy.distutils.misc_util import get_cmd
subpath = join('src', 'multiarray')
sources = [
join(local_dir, subpath, 'scalartypes.c.src'),
join(local_dir, subpath, 'arraytypes.c.src'),
join(local_dir, subpath, 'nditer_templ.c.src'),
join(local_dir, subpath, 'lowlevel_strided_loops.c.src'),
join(local_dir, subpath, 'einsum.c.src')
]
# numpy.distutils generate .c from .c.src in weird directories, we have
# to add them there as they depend on the build_dir
config.add_include_dirs(join(build_dir, subpath))
cmd = get_cmd('build_src')
cmd.ensure_finalized()
cmd.template_sources(sources, ext)
multiarray_deps = [
join('src', 'multiarray', 'arrayobject.h'),
join('src', 'multiarray', 'arraytypes.h'),
join('src', 'multiarray', 'array_assign.h'),
join('src', 'multiarray', 'buffer.h'),
join('src', 'multiarray', 'calculation.h'),
join('src', 'multiarray', 'common.h'),
join('src', 'multiarray', 'convert_datatype.h'),
join('src', 'multiarray', 'convert.h'),
join('src', 'multiarray', 'conversion_utils.h'),
join('src', 'multiarray', 'ctors.h'),
join('src', 'multiarray', 'descriptor.h'),
join('src', 'multiarray', 'getset.h'),
join('src', 'multiarray', 'hashdescr.h'),
join('src', 'multiarray', 'iterators.h'),
join('src', 'multiarray', 'mapping.h'),
join('src', 'multiarray', 'methods.h'),
join('src', 'multiarray', 'multiarraymodule.h'),
join('src', 'multiarray', 'nditer_impl.h'),
join('src', 'multiarray', 'numpymemoryview.h'),
join('src', 'multiarray', 'number.h'),
join('src', 'multiarray', 'numpyos.h'),
join('src', 'multiarray', 'refcount.h'),
join('src', 'multiarray', 'scalartypes.h'),
join('src', 'multiarray', 'sequence.h'),
join('src', 'multiarray', 'shape.h'),
join('src', 'multiarray', 'ucsnarrow.h'),
join('src', 'multiarray', 'usertypes.h'),
join('src', 'private', 'npy_config.h'),
join('src', 'private', 'lowlevel_strided_loops.h'),
join('include', 'numpy', 'arrayobject.h'),
join('include', 'numpy', '_neighborhood_iterator_imp.h'),
join('include', 'numpy', 'npy_endian.h'),
join('include', 'numpy', 'arrayscalars.h'),
join('include', 'numpy', 'noprefix.h'),
join('include', 'numpy', 'npy_interrupt.h'),
join('include', 'numpy', 'npy_3kcompat.h'),
join('include', 'numpy', 'npy_math.h'),
join('include', 'numpy', 'halffloat.h'),
join('include', 'numpy', 'npy_common.h'),
join('include', 'numpy', 'npy_os.h'),
join('include', 'numpy', 'utils.h'),
join('include', 'numpy', 'ndarrayobject.h'),
join('include', 'numpy', 'npy_cpu.h'),
join('include', 'numpy', 'numpyconfig.h'),
join('include', 'numpy', 'ndarraytypes.h'),
join('include', 'numpy', 'npy_1_7_deprecated_api.h'),
join('include', 'numpy', '_numpyconfig.h.in'),
# add library sources as distuils does not consider libraries
# dependencies
] + npysort_sources + npymath_sources
multiarray_src = [
join('src', 'multiarray', 'alloc.c'),
join('src', 'multiarray', 'arrayobject.c'),
join('src', 'multiarray', 'arraytypes.c.src'),
join('src', 'multiarray', 'array_assign.c'),
join('src', 'multiarray', 'array_assign_scalar.c'),
join('src', 'multiarray', 'array_assign_array.c'),
join('src', 'multiarray', 'buffer.c'),
join('src', 'multiarray', 'calculation.c'),
join('src', 'multiarray', 'common.c'),
join('src', 'multiarray', 'convert.c'),
join('src', 'multiarray', 'convert_datatype.c'),
join('src', 'multiarray', 'conversion_utils.c'),
join('src', 'multiarray', 'ctors.c'),
join('src', 'multiarray', 'datetime.c'),
join('src', 'multiarray', 'datetime_strings.c'),
join('src', 'multiarray', 'datetime_busday.c'),
join('src', 'multiarray', 'datetime_busdaycal.c'),
join('src', 'multiarray', 'descriptor.c'),
join('src', 'multiarray', 'dtype_transfer.c'),
join('src', 'multiarray', 'einsum.c.src'),
join('src', 'multiarray', 'flagsobject.c'),
join('src', 'multiarray', 'getset.c'),
join('src', 'multiarray', 'hashdescr.c'),
join('src', 'multiarray', 'item_selection.c'),
join('src', 'multiarray', 'iterators.c'),
join('src', 'multiarray', 'lowlevel_strided_loops.c.src'),
join('src', 'multiarray', 'mapping.c'),
join('src', 'multiarray', 'methods.c'),
join('src', 'multiarray', 'multiarraymodule.c'),
join('src', 'multiarray', 'nditer_templ.c.src'),
join('src', 'multiarray', 'nditer_api.c'),
join('src', 'multiarray', 'nditer_constr.c'),
join('src', 'multiarray', 'nditer_pywrap.c'),
join('src', 'multiarray', 'number.c'),
join('src', 'multiarray', 'numpymemoryview.c'),
join('src', 'multiarray', 'numpyos.c'),
join('src', 'multiarray', 'refcount.c'),
join('src', 'multiarray', 'sequence.c'),
join('src', 'multiarray', 'shape.c'),
join('src', 'multiarray', 'scalarapi.c'),
join('src', 'multiarray', 'scalartypes.c.src'),
join('src', 'multiarray', 'usertypes.c'),
join('src', 'multiarray', 'ucsnarrow.c')
]
if not ENABLE_SEPARATE_COMPILATION:
multiarray_deps.extend(multiarray_src)
multiarray_src = [
join('src', 'multiarray', 'multiarraymodule_onefile.c')
]
multiarray_src.append(generate_multiarray_templated_sources)
config.add_extension(
'multiarray',
sources=multiarray_src + [
generate_config_h, generate_numpyconfig_h, generate_numpy_api,
join(codegen_dir, 'generate_numpy_api.py'),
join('*.py')
],
depends=deps + multiarray_deps,
libraries=['npymath', 'npysort'])
#######################################################################
# umath module #
#######################################################################
# umath version: this function is needed to build foo.c from foo.c.src
# when foo.c is included in another file and as such not in the src
# argument of build_ext command
def generate_umath_templated_sources(ext, build_dir):
from numpy.distutils.misc_util import get_cmd
subpath = join('src', 'umath')
sources = [
join(local_dir, subpath, 'loops.h.src'),
join(local_dir, subpath, 'loops.c.src'),
join(local_dir, subpath, 'simd.inc.src')
]
# numpy.distutils generate .c from .c.src in weird directories, we have
# to add them there as they depend on the build_dir
config.add_include_dirs(join(build_dir, subpath))
cmd = get_cmd('build_src')
cmd.ensure_finalized()
cmd.template_sources(sources, ext)
def generate_umath_c(ext, build_dir):
target = join(build_dir, header_dir, '__umath_generated.c')
dir = os.path.dirname(target)
if not os.path.exists(dir):
os.makedirs(dir)
script = generate_umath_py
if newer(script, target):
f = open(target, 'w')
f.write(
generate_umath.make_code(generate_umath.defdict,
generate_umath.__file__))
f.close()
return []
umath_src = [
join('src', 'umath', 'umathmodule.c'),
join('src', 'umath', 'reduction.c'),
join('src', 'umath', 'funcs.inc.src'),
join('src', 'umath', 'simd.inc.src'),
join('src', 'umath', 'loops.h.src'),
join('src', 'umath', 'loops.c.src'),
join('src', 'umath', 'ufunc_object.c'),
join('src', 'umath', 'ufunc_type_resolution.c')
]
umath_deps = [
generate_umath_py,
join('src', 'multiarray', 'common.h'),
join('src', 'umath', 'simd.inc.src'),
join(codegen_dir, 'generate_ufunc_api.py'),
join('src', 'private', 'ufunc_override.h')
] + npymath_sources
if not ENABLE_SEPARATE_COMPILATION:
umath_deps.extend(umath_src)
umath_src = [join('src', 'umath', 'umathmodule_onefile.c')]
umath_src.append(generate_umath_templated_sources)
umath_src.append(join('src', 'umath', 'funcs.inc.src'))
umath_src.append(join('src', 'umath', 'simd.inc.src'))
config.add_extension(
'umath',
sources=umath_src + [
generate_config_h, generate_numpyconfig_h, generate_umath_c,
generate_ufunc_api
],
depends=deps + umath_deps,
libraries=['npymath'],
)
#######################################################################
# scalarmath module #
#######################################################################
config.add_extension(
'scalarmath',
sources=[
join('src', 'scalarmathmodule.c.src'),
join('src', 'private',
'scalarmathmodule.h.src'), generate_config_h,
generate_numpyconfig_h, generate_numpy_api, generate_ufunc_api
],
depends=deps + npymath_sources,
libraries=['npymath'],
)
#######################################################################
# _dotblas module #
#######################################################################
# Configure blasdot
blas_info = get_info('blas_opt', 0)
#blas_info = {}
def get_dotblas_sources(ext, build_dir):
if blas_info:
if ('NO_ATLAS_INFO', 1) in blas_info.get('define_macros', []):
return None # dotblas needs ATLAS, Fortran compiled blas will not be sufficient.
return ext.depends[:3]
return None # no extension module will be built
config.add_extension('_dotblas',
sources=[get_dotblas_sources],
depends=[
join('blasdot', '_dotblas.c'),
join('blasdot', 'python_xerbla.c'),
join('blasdot', 'apple_sgemv_patch.c'),
join('blasdot', 'cblas.h'),
],
include_dirs=['blasdot'],
extra_info=blas_info)
#######################################################################
# umath_tests module #
#######################################################################
config.add_extension('umath_tests',
sources=[join('src', 'umath', 'umath_tests.c.src')])
#######################################################################
# custom rational dtype module #
#######################################################################
config.add_extension('test_rational',
sources=[join('src', 'umath', 'test_rational.c.src')])
#######################################################################
# struct_ufunc_test module #
#######################################################################
config.add_extension(
'struct_ufunc_test',
sources=[join('src', 'umath', 'struct_ufunc_test.c.src')])
#######################################################################
# multiarray_tests module #
#######################################################################
config.add_extension(
'multiarray_tests',
sources=[join('src', 'multiarray', 'multiarray_tests.c.src')])
#######################################################################
# operand_flag_tests module #
#######################################################################
config.add_extension(
'operand_flag_tests',
sources=[join('src', 'umath', 'operand_flag_tests.c.src')])
config.add_data_dir('tests')
config.add_data_dir('tests/data')
config.make_svn_version_py()
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('fparser', parent_package, top_path)
config.add_data_files('log.config')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
from scipy._lib._boost_utils import _boost_dir
check_boost_submodule()
config = Configuration('_lib', parent_package, top_path)
config.add_data_files('tests/*.py')
include_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'src'))
depends = [os.path.join(include_dir, 'ccallback.h')]
config.add_extension("_ccallback_c",
sources=["_ccallback_c.c"],
depends=depends,
include_dirs=[include_dir])
config.add_extension("_test_ccallback",
sources=["src/_test_ccallback.c"],
depends=depends,
include_dirs=[include_dir])
config.add_extension("_fpumode",
sources=["_fpumode.c"])
def get_messagestream_config(ext, build_dir):
# Generate a header file containing defines
config_cmd = config.get_config_cmd()
defines = []
if config_cmd.check_func('open_memstream', decl=True, call=True):
defines.append(('HAVE_OPEN_MEMSTREAM', '1'))
target = os.path.join(os.path.dirname(__file__), 'src',
'messagestream_config.h')
with open(target, 'w') as f:
for name, value in defines:
f.write('#define {0} {1}\n'.format(name, value))
depends = [os.path.join(include_dir, 'messagestream.h')]
config.add_extension("messagestream",
sources=["messagestream.c"] + [get_messagestream_config],
depends=depends,
include_dirs=[include_dir])
config.add_extension("_test_deprecation_call",
sources=["_test_deprecation_call.c"],
include_dirs=[include_dir])
config.add_extension("_test_deprecation_def",
sources=["_test_deprecation_def.c"],
include_dirs=[include_dir])
config.add_subpackage('_uarray')
# ensure Boost was checked out and builds
config.add_library(
'test_boost_build',
sources=['tests/test_boost_build.cpp'],
include_dirs=_boost_dir(),
language='c++',
_pre_build_hook=build_clib_pre_build_hook)
return config
build_cython = ('--build_cython' in sys.argv)
if build_cython:
sys.argv.remove('--build_cython')
from Cython.Compiler.Main import compile
compile('pypico/pico.pyx')
config = Configuration(
'pypico',
name='pypico',
version='3.3.0',
author='Marius Millea',
author_email='*****@*****.**',
packages=['pypico'],
url='https://sites.google.com/a/ucdavis.edu/pico',
license='LICENSE.txt',
description=
'Quickly compute the CMB powerspectra and matter transfer functions.',
long_description=open('README.rst').read())
# Compile libpico.a
config.add_installed_library('pico', ['pypico/pico.c'], 'pypico',
{'include_dirs': [get_python_inc()]})
# Other files
config.add_data_files(('', 'pypico/fpico_interface.f90'))
config.add_data_files(('', 'pypico/pico.h'))
config.add_data_files('plugins/camb/*')
config.add_data_files('README.rst')
setup(**config.todict())
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from scipy._build_utils.compiler_helper import set_cxx_flags_hook
import numpy as np
config = Configuration('stats', parent_package, top_path)
config.add_data_dir('tests')
statlib_src = [join('statlib', '*.f')]
config.add_library('statlib', sources=statlib_src)
# add statlib module
config.add_extension('statlib',
sources=['statlib.pyf'],
f2py_options=['--no-wrap-functions'],
libraries=['statlib'],
depends=statlib_src)
# add _stats module
config.add_extension('_stats', sources=['_stats.c'])
# add mvn module
config.add_extension('mvn', sources=['mvn.pyf', 'mvndst.f'])
# add _sobol module
config.add_extension('_sobol', sources=['_sobol.c'])
config.add_data_files('_sobol_direction_numbers.npz')
# add _qmc_cy module
ext = config.add_extension('_qmc_cy', sources=['_qmc_cy.cxx'])
ext._pre_build_hook = set_cxx_flags_hook
# add BiasedUrn module
config.add_data_files('biasedurn.pxd')
from _generate_pyx import isNPY_OLD # type: ignore[import]
NPY_OLD = isNPY_OLD()
if NPY_OLD:
biasedurn_libs = []
biasedurn_libdirs = []
else:
biasedurn_libs = ['npyrandom', 'npymath']
biasedurn_libdirs = [
join(np.get_include(), '..', '..', 'random', 'lib')
]
biasedurn_libdirs += get_info('npymath')['library_dirs']
ext = config.add_extension(
'biasedurn',
sources=[
'biasedurn.cxx', 'biasedurn/impls.cpp', 'biasedurn/fnchyppr.cpp',
'biasedurn/wnchyppr.cpp', 'biasedurn/stoc1.cpp',
'biasedurn/stoc3.cpp'
],
include_dirs=[np.get_include()],
library_dirs=biasedurn_libdirs,
libraries=biasedurn_libs,
define_macros=[('R_BUILD', None)],
language='c++',
extra_compile_args=['-Wno-narrowing'] if system() == 'Darwin' else [],
depends=['biasedurn/stocR.h'],
)
ext._pre_build_hook = pre_build_hook
# Type stubs
config.add_data_files('*.pyi')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration, dot_join
from numpy.distutils.system_info import (get_info, blas_opt_info,
lapack_opt_info)
# Accelerate is buggy, disallow it. See also numpy/linalg/setup.py
for opt_order in (blas_opt_info.blas_order, lapack_opt_info.lapack_order):
if 'accelerate' in opt_order:
opt_order.remove('accelerate')
config = Configuration('core', parent_package, top_path)
local_dir = config.local_path
codegen_dir = join(local_dir, 'code_generators')
if is_released(config):
warnings.simplefilter('error', MismatchCAPIWarning)
# Check whether we have a mismatch between the set C API VERSION and the
# actual C API VERSION
check_api_version(C_API_VERSION, codegen_dir)
generate_umath_py = join(codegen_dir, 'generate_umath.py')
n = dot_join(config.name, 'generate_umath')
generate_umath = npy_load_module('_'.join(n.split('.')),
generate_umath_py, ('.py', 'U', 1))
header_dir = 'include/numpy' # this is relative to config.path_in_package
cocache = CallOnceOnly()
def generate_config_h(ext, build_dir):
target = join(build_dir, header_dir, 'config.h')
d = os.path.dirname(target)
if not os.path.exists(d):
os.makedirs(d)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
# Check sizeof
moredefs, ignored = cocache.check_types(config_cmd, ext, build_dir)
# Check math library and C99 math funcs availability
mathlibs = check_mathlib(config_cmd)
moredefs.append(('MATHLIB', ','.join(mathlibs)))
check_math_capabilities(config_cmd, moredefs, mathlibs)
moredefs.extend(cocache.check_ieee_macros(config_cmd)[0])
moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[0])
# Signal check
if is_npy_no_signal():
moredefs.append('__NPY_PRIVATE_NO_SIGNAL')
# Windows checks
if sys.platform == 'win32' or os.name == 'nt':
win32_checks(moredefs)
# C99 restrict keyword
moredefs.append(('NPY_RESTRICT', config_cmd.check_restrict()))
# Inline check
inline = config_cmd.check_inline()
# Use relaxed stride checking
if NPY_RELAXED_STRIDES_CHECKING:
moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
# Use bogus stride debug aid when relaxed strides are enabled
if NPY_RELAXED_STRIDES_DEBUG:
moredefs.append(('NPY_RELAXED_STRIDES_DEBUG', 1))
# Get long double representation
rep = check_long_double_representation(config_cmd)
moredefs.append(('HAVE_LDOUBLE_%s' % rep, 1))
if check_for_right_shift_internal_compiler_error(config_cmd):
moredefs.append('NPY_DO_NOT_OPTIMIZE_LONG_right_shift')
moredefs.append('NPY_DO_NOT_OPTIMIZE_ULONG_right_shift')
moredefs.append('NPY_DO_NOT_OPTIMIZE_LONGLONG_right_shift')
moredefs.append('NPY_DO_NOT_OPTIMIZE_ULONGLONG_right_shift')
# Generate the config.h file from moredefs
with open(target, 'w') as target_f:
for d in moredefs:
if isinstance(d, str):
target_f.write('#define %s\n' % (d))
else:
target_f.write('#define %s %s\n' % (d[0], d[1]))
# define inline to our keyword, or nothing
target_f.write('#ifndef __cplusplus\n')
if inline == 'inline':
target_f.write('/* #undef inline */\n')
else:
target_f.write('#define inline %s\n' % inline)
target_f.write('#endif\n')
# add the guard to make sure config.h is never included directly,
# but always through npy_config.h
target_f.write(textwrap.dedent("""
#ifndef _NPY_NPY_CONFIG_H_
#error config.h should never be included directly, include npy_config.h instead
#endif
"""))
log.info('File: %s' % target)
with open(target) as target_f:
log.info(target_f.read())
log.info('EOF')
else:
mathlibs = []
with open(target) as target_f:
for line in target_f:
s = '#define MATHLIB'
if line.startswith(s):
value = line[len(s):].strip()
if value:
mathlibs.extend(value.split(','))
# Ugly: this can be called within a library and not an extension,
# in which case there is no libraries attributes (and none is
# needed).
if hasattr(ext, 'libraries'):
ext.libraries.extend(mathlibs)
incl_dir = os.path.dirname(target)
if incl_dir not in config.numpy_include_dirs:
config.numpy_include_dirs.append(incl_dir)
return target
def generate_numpyconfig_h(ext, build_dir):
"""Depends on config.h: generate_config_h has to be called before !"""
# put common include directory in build_dir on search path
# allows using code generation in headers
config.add_include_dirs(join(build_dir, "src", "common"))
config.add_include_dirs(join(build_dir, "src", "npymath"))
target = join(build_dir, header_dir, '_numpyconfig.h')
d = os.path.dirname(target)
if not os.path.exists(d):
os.makedirs(d)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
# Check sizeof
ignored, moredefs = cocache.check_types(config_cmd, ext, build_dir)
if is_npy_no_signal():
moredefs.append(('NPY_NO_SIGNAL', 1))
if is_npy_no_smp():
moredefs.append(('NPY_NO_SMP', 1))
else:
moredefs.append(('NPY_NO_SMP', 0))
mathlibs = check_mathlib(config_cmd)
moredefs.extend(cocache.check_ieee_macros(config_cmd)[1])
moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[1])
if NPY_RELAXED_STRIDES_CHECKING:
moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
if NPY_RELAXED_STRIDES_DEBUG:
moredefs.append(('NPY_RELAXED_STRIDES_DEBUG', 1))
# Check whether we can use inttypes (C99) formats
if config_cmd.check_decl('PRIdPTR', headers=['inttypes.h']):
moredefs.append(('NPY_USE_C99_FORMATS', 1))
# visibility check
hidden_visibility = visibility_define(config_cmd)
moredefs.append(('NPY_VISIBILITY_HIDDEN', hidden_visibility))
# Add the C API/ABI versions
moredefs.append(('NPY_ABI_VERSION', '0x%.8X' % C_ABI_VERSION))
moredefs.append(('NPY_API_VERSION', '0x%.8X' % C_API_VERSION))
# Add moredefs to header
with open(target, 'w') as target_f:
for d in moredefs:
if isinstance(d, str):
target_f.write('#define %s\n' % (d))
else:
target_f.write('#define %s %s\n' % (d[0], d[1]))
# Define __STDC_FORMAT_MACROS
target_f.write(textwrap.dedent("""
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS 1
#endif
"""))
# Dump the numpyconfig.h header to stdout
log.info('File: %s' % target)
with open(target) as target_f:
log.info(target_f.read())
log.info('EOF')
config.add_data_files((header_dir, target))
return target
def generate_api_func(module_name):
def generate_api(ext, build_dir):
script = join(codegen_dir, module_name + '.py')
sys.path.insert(0, codegen_dir)
try:
m = __import__(module_name)
log.info('executing %s', script)
h_file, c_file, doc_file = m.generate_api(os.path.join(build_dir, header_dir))
finally:
del sys.path[0]
config.add_data_files((header_dir, h_file),
(header_dir, doc_file))
return (h_file,)
return generate_api
generate_numpy_api = generate_api_func('generate_numpy_api')
generate_ufunc_api = generate_api_func('generate_ufunc_api')
config.add_include_dirs(join(local_dir, "src", "common"))
config.add_include_dirs(join(local_dir, "src"))
config.add_include_dirs(join(local_dir))
config.add_data_dir('include/numpy')
config.add_include_dirs(join('src', 'npymath'))
config.add_include_dirs(join('src', 'multiarray'))
config.add_include_dirs(join('src', 'umath'))
config.add_include_dirs(join('src', 'npysort'))
config.add_define_macros([("NPY_INTERNAL_BUILD", "1")]) # this macro indicates that Numpy build is in process
config.add_define_macros([("HAVE_NPY_CONFIG_H", "1")])
if sys.platform[:3] == "aix":
config.add_define_macros([("_LARGE_FILES", None)])
else:
config.add_define_macros([("_FILE_OFFSET_BITS", "64")])
config.add_define_macros([('_LARGEFILE_SOURCE', '1')])
config.add_define_macros([('_LARGEFILE64_SOURCE', '1')])
config.numpy_include_dirs.extend(config.paths('include'))
deps = [join('src', 'npymath', '_signbit.c'),
join('include', 'numpy', '*object.h'),
join(codegen_dir, 'genapi.py'),
]
#######################################################################
# npymath library #
#######################################################################
subst_dict = dict([("sep", os.path.sep), ("pkgname", "numpy.core")])
def get_mathlib_info(*args):
# Another ugly hack: the mathlib info is known once build_src is run,
# but we cannot use add_installed_pkg_config here either, so we only
# update the substitution dictionary during npymath build
config_cmd = config.get_config_cmd()
# Check that the toolchain works, to fail early if it doesn't
# (avoid late errors with MATHLIB which are confusing if the
# compiler does not work).
st = config_cmd.try_link('int main(void) { return 0;}')
if not st:
# rerun the failing command in verbose mode
config_cmd.compiler.verbose = True
config_cmd.try_link('int main(void) { return 0;}')
raise RuntimeError("Broken toolchain: cannot link a simple C program")
mlibs = check_mathlib(config_cmd)
posix_mlib = ' '.join(['-l%s' % l for l in mlibs])
msvc_mlib = ' '.join(['%s.lib' % l for l in mlibs])
subst_dict["posix_mathlib"] = posix_mlib
subst_dict["msvc_mathlib"] = msvc_mlib
npymath_sources = [join('src', 'npymath', 'npy_math_internal.h.src'),
join('src', 'npymath', 'npy_math.c'),
join('src', 'npymath', 'ieee754.c.src'),
join('src', 'npymath', 'npy_math_complex.c.src'),
join('src', 'npymath', 'halffloat.c')
]
# Must be true for CRT compilers but not MinGW/cygwin. See gh-9977.
# Intel and Clang also don't seem happy with /GL
is_msvc = (platform.platform().startswith('Windows') and
platform.python_compiler().startswith('MS'))
config.add_installed_library('npymath',
sources=npymath_sources + [get_mathlib_info],
install_dir='lib',
build_info={
'include_dirs' : [], # empty list required for creating npy_math_internal.h
'extra_compiler_args' : (['/GL-'] if is_msvc else []),
})
config.add_npy_pkg_config("npymath.ini.in", "lib/npy-pkg-config",
subst_dict)
config.add_npy_pkg_config("mlib.ini.in", "lib/npy-pkg-config",
subst_dict)
#######################################################################
# npysort library #
#######################################################################
# This library is created for the build but it is not installed
npysort_sources = [join('src', 'common', 'npy_sort.h.src'),
join('src', 'npysort', 'quicksort.c.src'),
join('src', 'npysort', 'mergesort.c.src'),
join('src', 'npysort', 'timsort.c.src'),
join('src', 'npysort', 'heapsort.c.src'),
join('src', 'npysort', 'radixsort.c.src'),
join('src', 'common', 'npy_partition.h.src'),
join('src', 'npysort', 'selection.c.src'),
join('src', 'common', 'npy_binsearch.h.src'),
join('src', 'npysort', 'binsearch.c.src'),
]
config.add_library('npysort',
sources=npysort_sources,
include_dirs=[])
#######################################################################
# multiarray_tests module #
#######################################################################
config.add_extension('_multiarray_tests',
sources=[join('src', 'multiarray', '_multiarray_tests.c.src'),
join('src', 'common', 'mem_overlap.c')],
depends=[join('src', 'common', 'mem_overlap.h'),
join('src', 'common', 'npy_extint128.h')],
libraries=['npymath'])
#######################################################################
# _multiarray_umath module - common part #
#######################################################################
common_deps = [
join('src', 'common', 'array_assign.h'),
join('src', 'common', 'binop_override.h'),
join('src', 'common', 'cblasfuncs.h'),
join('src', 'common', 'lowlevel_strided_loops.h'),
join('src', 'common', 'mem_overlap.h'),
join('src', 'common', 'npy_cblas.h'),
join('src', 'common', 'npy_config.h'),
join('src', 'common', 'npy_ctypes.h'),
join('src', 'common', 'npy_extint128.h'),
join('src', 'common', 'npy_import.h'),
join('src', 'common', 'npy_longdouble.h'),
join('src', 'common', 'templ_common.h.src'),
join('src', 'common', 'ucsnarrow.h'),
join('src', 'common', 'ufunc_override.h'),
join('src', 'common', 'umathmodule.h'),
join('src', 'common', 'numpyos.h'),
join('src', 'common', 'npy_cpu_dispatch.h'),
]
common_src = [
join('src', 'common', 'array_assign.c'),
join('src', 'common', 'mem_overlap.c'),
join('src', 'common', 'npy_longdouble.c'),
join('src', 'common', 'templ_common.h.src'),
join('src', 'common', 'ucsnarrow.c'),
join('src', 'common', 'ufunc_override.c'),
join('src', 'common', 'numpyos.c'),
join('src', 'common', 'npy_cpu_features.c.src'),
]
if os.environ.get('NPY_USE_BLAS_ILP64', "0") != "0":
blas_info = get_info('blas_ilp64_opt', 2)
else:
blas_info = get_info('blas_opt', 0)
have_blas = blas_info and ('HAVE_CBLAS', None) in blas_info.get('define_macros', [])
if have_blas:
extra_info = blas_info
# These files are also in MANIFEST.in so that they are always in
# the source distribution independently of HAVE_CBLAS.
common_src.extend([join('src', 'common', 'cblasfuncs.c'),
join('src', 'common', 'python_xerbla.c'),
])
else:
extra_info = {}
#######################################################################
# _multiarray_umath module - multiarray part #
#######################################################################
multiarray_deps = [
join('src', 'multiarray', 'abstractdtypes.h'),
join('src', 'multiarray', 'arrayobject.h'),
join('src', 'multiarray', 'arraytypes.h'),
join('src', 'multiarray', 'arrayfunction_override.h'),
join('src', 'multiarray', 'array_coercion.h'),
join('src', 'multiarray', 'npy_buffer.h'),
join('src', 'multiarray', 'calculation.h'),
join('src', 'multiarray', 'common.h'),
join('src', 'multiarray', 'convert_datatype.h'),
join('src', 'multiarray', 'convert.h'),
join('src', 'multiarray', 'conversion_utils.h'),
join('src', 'multiarray', 'ctors.h'),
join('src', 'multiarray', 'descriptor.h'),
join('src', 'multiarray', 'dtypemeta.h'),
join('src', 'multiarray', 'dragon4.h'),
join('src', 'multiarray', 'getset.h'),
join('src', 'multiarray', 'hashdescr.h'),
join('src', 'multiarray', 'iterators.h'),
join('src', 'multiarray', 'mapping.h'),
join('src', 'multiarray', 'methods.h'),
join('src', 'multiarray', 'multiarraymodule.h'),
join('src', 'multiarray', 'nditer_impl.h'),
join('src', 'multiarray', 'number.h'),
join('src', 'multiarray', 'refcount.h'),
join('src', 'multiarray', 'scalartypes.h'),
join('src', 'multiarray', 'sequence.h'),
join('src', 'multiarray', 'shape.h'),
join('src', 'multiarray', 'strfuncs.h'),
join('src', 'multiarray', 'typeinfo.h'),
join('src', 'multiarray', 'usertypes.h'),
join('src', 'multiarray', 'vdot.h'),
join('include', 'numpy', 'arrayobject.h'),
join('include', 'numpy', '_neighborhood_iterator_imp.h'),
join('include', 'numpy', 'npy_endian.h'),
join('include', 'numpy', 'arrayscalars.h'),
join('include', 'numpy', 'noprefix.h'),
join('include', 'numpy', 'npy_interrupt.h'),
join('include', 'numpy', 'npy_3kcompat.h'),
join('include', 'numpy', 'npy_math.h'),
join('include', 'numpy', 'halffloat.h'),
join('include', 'numpy', 'npy_common.h'),
join('include', 'numpy', 'npy_os.h'),
join('include', 'numpy', 'utils.h'),
join('include', 'numpy', 'ndarrayobject.h'),
join('include', 'numpy', 'npy_cpu.h'),
join('include', 'numpy', 'numpyconfig.h'),
join('include', 'numpy', 'ndarraytypes.h'),
join('include', 'numpy', 'npy_1_7_deprecated_api.h'),
# add library sources as distuils does not consider libraries
# dependencies
] + npysort_sources + npymath_sources
multiarray_src = [
join('src', 'multiarray', 'abstractdtypes.c'),
join('src', 'multiarray', 'alloc.c'),
join('src', 'multiarray', 'arrayobject.c'),
join('src', 'multiarray', 'arraytypes.c.src'),
join('src', 'multiarray', 'array_coercion.c'),
join('src', 'multiarray', 'array_assign_scalar.c'),
join('src', 'multiarray', 'array_assign_array.c'),
join('src', 'multiarray', 'arrayfunction_override.c'),
join('src', 'multiarray', 'buffer.c'),
join('src', 'multiarray', 'calculation.c'),
join('src', 'multiarray', 'compiled_base.c'),
join('src', 'multiarray', 'common.c'),
join('src', 'multiarray', 'convert.c'),
join('src', 'multiarray', 'convert_datatype.c'),
join('src', 'multiarray', 'conversion_utils.c'),
join('src', 'multiarray', 'ctors.c'),
join('src', 'multiarray', 'datetime.c'),
join('src', 'multiarray', 'datetime_strings.c'),
join('src', 'multiarray', 'datetime_busday.c'),
join('src', 'multiarray', 'datetime_busdaycal.c'),
join('src', 'multiarray', 'descriptor.c'),
join('src', 'multiarray', 'dtypemeta.c'),
join('src', 'multiarray', 'dragon4.c'),
join('src', 'multiarray', 'dtype_transfer.c'),
join('src', 'multiarray', 'einsum.c.src'),
join('src', 'multiarray', 'flagsobject.c'),
join('src', 'multiarray', 'getset.c'),
join('src', 'multiarray', 'hashdescr.c'),
join('src', 'multiarray', 'item_selection.c'),
join('src', 'multiarray', 'iterators.c'),
join('src', 'multiarray', 'lowlevel_strided_loops.c.src'),
join('src', 'multiarray', 'mapping.c'),
join('src', 'multiarray', 'methods.c'),
join('src', 'multiarray', 'multiarraymodule.c'),
join('src', 'multiarray', 'nditer_templ.c.src'),
join('src', 'multiarray', 'nditer_api.c'),
join('src', 'multiarray', 'nditer_constr.c'),
join('src', 'multiarray', 'nditer_pywrap.c'),
join('src', 'multiarray', 'number.c'),
join('src', 'multiarray', 'refcount.c'),
join('src', 'multiarray', 'sequence.c'),
join('src', 'multiarray', 'shape.c'),
join('src', 'multiarray', 'scalarapi.c'),
join('src', 'multiarray', 'scalartypes.c.src'),
join('src', 'multiarray', 'strfuncs.c'),
join('src', 'multiarray', 'temp_elide.c'),
join('src', 'multiarray', 'typeinfo.c'),
join('src', 'multiarray', 'usertypes.c'),
join('src', 'multiarray', 'vdot.c'),
]
#######################################################################
# _multiarray_umath module - umath part #
#######################################################################
def generate_umath_c(ext, build_dir):
target = join(build_dir, header_dir, '__umath_generated.c')
dir = os.path.dirname(target)
if not os.path.exists(dir):
os.makedirs(dir)
script = generate_umath_py
if newer(script, target):
with open(target, 'w') as f:
f.write(generate_umath.make_code(generate_umath.defdict,
generate_umath.__file__))
return []
umath_src = [
join('src', 'umath', 'umathmodule.c'),
join('src', 'umath', 'reduction.c'),
join('src', 'umath', 'funcs.inc.src'),
join('src', 'umath', 'simd.inc.src'),
join('src', 'umath', 'loops.h.src'),
join('src', 'umath', 'loops.c.src'),
join('src', 'umath', 'matmul.h.src'),
join('src', 'umath', 'matmul.c.src'),
join('src', 'umath', 'clip.h.src'),
join('src', 'umath', 'clip.c.src'),
join('src', 'umath', 'ufunc_object.c'),
join('src', 'umath', 'extobj.c'),
join('src', 'umath', 'scalarmath.c.src'),
join('src', 'umath', 'ufunc_type_resolution.c'),
join('src', 'umath', 'override.c'),
]
umath_deps = [
generate_umath_py,
join('include', 'numpy', 'npy_math.h'),
join('include', 'numpy', 'halffloat.h'),
join('src', 'multiarray', 'common.h'),
join('src', 'multiarray', 'number.h'),
join('src', 'common', 'templ_common.h.src'),
join('src', 'umath', 'simd.inc.src'),
join('src', 'umath', 'override.h'),
join(codegen_dir, 'generate_ufunc_api.py'),
]
config.add_extension('_multiarray_umath',
sources=multiarray_src + umath_src +
npymath_sources + common_src +
[generate_config_h,
generate_numpyconfig_h,
generate_numpy_api,
join(codegen_dir, 'generate_numpy_api.py'),
join('*.py'),
generate_umath_c,
generate_ufunc_api,
],
depends=deps + multiarray_deps + umath_deps +
common_deps,
libraries=['npymath', 'npysort'],
extra_info=extra_info)
#######################################################################
# umath_tests module #
#######################################################################
config.add_extension('_umath_tests', sources=[
join('src', 'umath', '_umath_tests.c.src'),
join('src', 'umath', '_umath_tests.dispatch.c'),
join('src', 'common', 'npy_cpu_features.c.src'),
])
#######################################################################
# custom rational dtype module #
#######################################################################
config.add_extension('_rational_tests',
sources=[join('src', 'umath', '_rational_tests.c.src')])
#######################################################################
# struct_ufunc_test module #
#######################################################################
config.add_extension('_struct_ufunc_tests',
sources=[join('src', 'umath', '_struct_ufunc_tests.c.src')])
#######################################################################
# operand_flag_tests module #
#######################################################################
config.add_extension('_operand_flag_tests',
sources=[join('src', 'umath', '_operand_flag_tests.c.src')])
config.add_subpackage('tests')
config.add_data_dir('tests/data')
config.add_data_dir('tests/examples')
config.add_data_files('*.pyi')
config.make_svn_version_py()
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, get_mathlibs
config = Configuration('random', parent_package, top_path)
def generate_libraries(ext, build_dir):
config_cmd = config.get_config_cmd()
libs = get_mathlibs()
if sys.platform == 'win32':
libs.extend(['Advapi32', 'Kernel32'])
ext.libraries.extend(libs)
return None
# enable unix large file support on 32 bit systems
# (64 bit off_t, lseek -> lseek64 etc.)
if sys.platform[:3] == "aix":
defs = [('_LARGE_FILES', None)]
else:
defs = [('_FILE_OFFSET_BITS', '64'), ('_LARGEFILE_SOURCE', '1'),
('_LARGEFILE64_SOURCE', '1')]
defs.append(('NPY_NO_DEPRECATED_API', 0))
config.add_data_dir('tests')
config.add_data_dir('_examples')
EXTRA_LINK_ARGS = []
EXTRA_LIBRARIES = ['npyrandom']
if os.name != 'nt':
# Math lib
EXTRA_LIBRARIES.append('m')
# Some bit generators exclude GCC inlining
EXTRA_COMPILE_ARGS = ['-U__GNUC_GNU_INLINE__']
if is_msvc and platform_bits == 32:
# 32-bit windows requires explicit sse2 option
EXTRA_COMPILE_ARGS += ['/arch:SSE2']
elif not is_msvc:
# Some bit generators require c99
EXTRA_COMPILE_ARGS += ['-std=c99']
# Use legacy integer variable sizes
LEGACY_DEFS = [('NP_RANDOM_LEGACY', '1')]
PCG64_DEFS = []
# One can force emulated 128-bit arithmetic if one wants.
#PCG64_DEFS += [('PCG_FORCE_EMULATED_128BIT_MATH', '1')]
depends = ['__init__.pxd', 'c_distributions.pxd', 'bit_generator.pxd']
# npyrandom - a library like npymath
npyrandom_sources = [
'src/distributions/logfactorial.c',
'src/distributions/distributions.c',
'src/distributions/random_mvhg_count.c',
'src/distributions/random_mvhg_marginals.c',
'src/distributions/random_hypergeometric.c',
]
config.add_installed_library(
'npyrandom',
sources=npyrandom_sources,
install_dir='lib',
build_info={
'include_dirs': [], # empty list required for creating npyrandom.h
'extra_compiler_args': (['/GL-'] if is_msvc else []),
})
for gen in ['mt19937']:
# gen.pyx, src/gen/gen.c, src/gen/gen-jump.c
config.add_extension(
f'_{gen}',
sources=[
f'_{gen}.c', f'src/{gen}/{gen}.c', f'src/{gen}/{gen}-jump.c'
],
include_dirs=['.', 'src', join('src', gen)],
libraries=EXTRA_LIBRARIES,
extra_compile_args=EXTRA_COMPILE_ARGS,
extra_link_args=EXTRA_LINK_ARGS,
depends=depends + [f'_{gen}.pyx'],
define_macros=defs,
)
for gen in ['philox', 'pcg64', 'sfc64']:
# gen.pyx, src/gen/gen.c
_defs = defs + PCG64_DEFS if gen == 'pcg64' else defs
config.add_extension(
f'_{gen}',
sources=[f'_{gen}.c', f'src/{gen}/{gen}.c'],
include_dirs=['.', 'src', join('src', gen)],
libraries=EXTRA_LIBRARIES,
extra_compile_args=EXTRA_COMPILE_ARGS,
extra_link_args=EXTRA_LINK_ARGS,
depends=depends +
[f'_{gen}.pyx', 'bit_generator.pyx', 'bit_generator.pxd'],
define_macros=_defs,
)
for gen in ['_common', 'bit_generator']:
# gen.pyx
config.add_extension(
gen,
sources=[f'{gen}.c'],
libraries=EXTRA_LIBRARIES,
extra_compile_args=EXTRA_COMPILE_ARGS,
extra_link_args=EXTRA_LINK_ARGS,
include_dirs=['.', 'src'],
depends=depends + [
f'{gen}.pyx',
f'{gen}.pxd',
],
define_macros=defs,
)
config.add_data_files('{gen}.pxd')
for gen in ['_generator', '_bounded_integers']:
# gen.pyx, src/distributions/distributions.c
config.add_extension(
gen,
sources=[f'{gen}.c'],
libraries=EXTRA_LIBRARIES,
extra_compile_args=EXTRA_COMPILE_ARGS,
include_dirs=['.', 'src'],
extra_link_args=EXTRA_LINK_ARGS,
depends=depends + [f'{gen}.pyx'],
define_macros=defs,
)
config.add_data_files('_bounded_integers.pxd')
config.add_extension(
'mtrand',
sources=[
'mtrand.c',
'src/legacy/legacy-distributions.c',
'src/distributions/distributions.c',
],
include_dirs=['.', 'src', 'src/legacy'],
libraries=['m'] if os.name != 'nt' else [],
extra_compile_args=EXTRA_COMPILE_ARGS,
extra_link_args=EXTRA_LINK_ARGS,
depends=depends + ['mtrand.pyx'],
define_macros=defs + LEGACY_DEFS,
)
config.add_data_files(*depends)
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs
from numpy.distutils.misc_util import get_info as get_misc_info
from scipy._build_utils.system_info import get_info
from scipy._build_utils import combine_dict, uses_blas64, numpy_nodepr_api
from scipy._build_utils.compiler_helper import set_cxx_flags_hook
from distutils.sysconfig import get_python_inc
import pybind11
config = Configuration('spatial', parent_package, top_path)
config.add_data_dir('tests')
# spatial.transform
config.add_subpackage('transform')
# qhull
qhull_src = sorted(
glob.glob(join(dirname(__file__), 'qhull_src', 'src', '*.c')))
inc_dirs = [get_python_inc()]
if inc_dirs[0] != get_python_inc(plat_specific=1):
inc_dirs.append(get_python_inc(plat_specific=1))
inc_dirs.append(get_numpy_include_dirs())
inc_dirs.append(join(dirname(dirname(__file__)), '_lib'))
inc_dirs.append(join(dirname(dirname(__file__)), '_build_utils', 'src'))
if uses_blas64():
lapack_opt = get_info('lapack_ilp64_opt')
else:
lapack_opt = get_info('lapack_opt')
cfg = combine_dict(lapack_opt, include_dirs=inc_dirs)
config.add_extension('qhull',
sources=['qhull.c', 'qhull_misc.c'] + qhull_src,
**cfg)
# cKDTree
ckdtree_src = [
'query.cxx', 'build.cxx', 'query_pairs.cxx', 'count_neighbors.cxx',
'query_ball_point.cxx', 'query_ball_tree.cxx', 'sparse_distances.cxx'
]
ckdtree_src = [join('ckdtree', 'src', x) for x in ckdtree_src]
ckdtree_headers = [
'ckdtree_decl.h', 'coo_entries.h', 'distance_base.h', 'distance.h',
'ordered_pair.h', 'rectangle.h'
]
ckdtree_headers = [join('ckdtree', 'src', x) for x in ckdtree_headers]
ckdtree_dep = ['ckdtree.cxx'] + ckdtree_headers + ckdtree_src
ext = config.add_extension('ckdtree',
sources=['ckdtree.cxx'] + ckdtree_src,
depends=ckdtree_dep,
include_dirs=inc_dirs +
[join('ckdtree', 'src')])
ext._pre_build_hook = set_cxx_flags_hook
# _distance_wrap
config.add_extension('_distance_wrap',
sources=[join('src', 'distance_wrap.c')],
depends=[join('src', 'distance_impl.h')],
include_dirs=[
get_numpy_include_dirs(),
join(dirname(dirname(__file__)), '_lib')
],
extra_info=get_misc_info("npymath"))
distance_pybind_includes = [
pybind11.get_include(True),
pybind11.get_include(False),
get_numpy_include_dirs()
]
ext = config.add_extension('_distance_pybind',
sources=[join('src', 'distance_pybind.cpp')],
depends=[
join('src', 'function_ref.h'),
join('src', 'views.h'),
join('src', 'distance_metrics.h')
],
include_dirs=distance_pybind_includes,
language='c++',
**numpy_nodepr_api)
ext._pre_build_hook = pre_build_hook
config.add_extension('_voronoi', sources=['_voronoi.c'])
config.add_extension('_hausdorff', sources=['_hausdorff.c'])
# Add license files
config.add_data_files('qhull_src/COPYING.txt')
# Type stubs
config.add_data_files('*.pyi')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration(None, parent_package, top_path)
config.set_options(ignore_setup_xxx_py=True,
assume_default_configuration=True,
delegate_options_to_subpackages=True,
quiet=True)
config.add_subpackage('sfepy')
main_scripts = [
'phonon.py',
'extractor.py',
'homogen.py',
'postproc.py',
'probe.py',
'run_tests.py',
'schroedinger.py',
'simple.py',
'test_install.py',
]
aux_scripts = [
'blockgen.py',
'convert_mesh.py',
'cylindergen.py',
'edit_identifiers.py',
'eval_ns_forms.py',
'eval_tl_forms.py',
'extract_surface.py',
'gen_gallery.py',
'gen_iga_patch.py',
'gen_lobatto1d_c.py',
'gen_mesh_prev.py',
'gen_solver_table.py',
'gen_term_table.py',
'plot_condition_numbers.py',
'plot_logs.py',
'plot_mesh.py',
'plot_quadratures.py',
'plot_times.py',
'save_basis.py',
'show_authors.py',
'show_mesh_info.py',
'show_terms_use.py',
'sync_module_docs.py',
'tile_periodic_mesh.py',
]
aux_scripts = [os.path.join('script', ii) for ii in aux_scripts]
config.add_data_files(('sfepy', ('VERSION', 'INSTALL', 'README.rst',
'LICENSE', 'AUTHORS', 'build_helpers.py',
'site_cfg_template.py', 'Makefile')))
config.add_data_files(('sfepy/script', main_scripts))
config.add_data_files(('sfepy/script', aux_scripts))
config.add_data_dir(('sfepy/meshes', 'meshes'))
config.add_data_dir(('sfepy/examples', 'examples'))
config.add_data_dir(('sfepy/tests', 'tests'))
config.get_version('sfepy/version.py') # sets config.version
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('_highs', parent_package, top_path)
# HiGHS info
_major_dot_minor = _get_version('CMakeLists.txt', 'project(HIGHS VERSION',
'LANGUAGES CXX C')
HIGHS_VERSION_MAJOR, HIGHS_VERSION_MINOR = _major_dot_minor.split('.')
HIGHS_VERSION_PATCH = _get_version('CMakeLists.txt', 'HIGHS_VERSION_PATCH')
GITHASH = 'n/a'
HIGHS_DIR = str(pathlib.Path(__file__).parent.resolve())
# Here are the pound defines that HConfig.h would usually provide;
# We provide an empty HConfig.h file and do the defs and undefs
# here:
TODAY_DATE = datetime.today().strftime('%Y-%m-%d')
DEFINE_MACROS = [
('CMAKE_BUILD_TYPE', '"Release"'),
('HiGHSRELEASE', None),
('IPX_ON', 'ON'),
('HIGHS_GITHASH', '"%s"' % GITHASH),
('HIGHS_COMPILATION_DATE', '"' + TODAY_DATE + '"'),
('HIGHS_VERSION_MAJOR', HIGHS_VERSION_MAJOR),
('HIGHS_VERSION_MINOR', HIGHS_VERSION_MINOR),
('HIGHS_VERSION_PATCH', HIGHS_VERSION_PATCH),
('HIGHS_DIR', '"' + HIGHS_DIR + '"'),
# ('NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION', None),
]
UNDEF_MACROS = [
'OPENMP', # unconditionally disable openmp
'EXT_PRESOLVE',
'SCIP_DEV',
'HiGHSDEV',
'OSI_FOUND',
]
# Compile BASICLU as a static library to appease clang:
# (won't allow -std=c++11/14 option for C sources)
basiclu_sources = _get_sources('src/CMakeLists.txt',
'set(basiclu_sources\n', ')')
config.add_library(
'basiclu',
sources=basiclu_sources,
include_dirs=[
'src/',
'src/ipm/basiclu/include/',
],
language='c',
macros=DEFINE_MACROS,
_pre_build_hook=basiclu_pre_build_hook,
)
# highs_wrapper:
ipx_sources = _get_sources('src/CMakeLists.txt', 'set(ipx_sources\n', ')')
highs_sources = _get_sources('src/CMakeLists.txt', 'set(sources\n', ')')
# filter out MIP sources until MIP is officially supported
highs_sources = [
s for s in highs_sources if pathlib.Path(s).parent.name != 'mip'
]
ext = config.add_extension(
'_highs_wrapper',
sources=['cython/src/_highs_wrapper.cxx'] + highs_sources +
ipx_sources,
include_dirs=[
# highs_wrapper
'cython/src/',
'src/',
'src/lp_data/',
# highs
'src/',
'src/io/',
'src/ipm/ipx/include/',
# IPX
'src/ipm/ipx/include/',
'src/ipm/basiclu/include/',
],
language='c++',
libraries=['basiclu'],
define_macros=DEFINE_MACROS,
undef_macros=UNDEF_MACROS,
)
# Add c++11/14 support:
ext._pre_build_hook = pre_build_hook
# Export constants and enums from HiGHS:
ext = config.add_extension(
'_highs_constants',
sources=['cython/src/_highs_constants.cxx'],
include_dirs=[
'cython/src/',
'src/',
'src/io/',
'src/lp_data/',
'src/simplex/',
],
language='c++',
)
ext._pre_build_hook = pre_build_hook
config.add_data_files(os.path.join('cython', 'src', '*.pxd'))
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info as get_system_info
config = Configuration('special', parent_package, top_path)
define_macros = []
if sys.platform == 'win32':
# define_macros.append(('NOINFINITIES',None))
# define_macros.append(('NONANS',None))
define_macros.append(('_USE_MATH_DEFINES', None))
curdir = os.path.abspath(os.path.dirname(__file__))
inc_dirs = [get_python_inc(), os.path.join(curdir, "c_misc")]
if inc_dirs[0] != get_python_inc(plat_specific=1):
inc_dirs.append(get_python_inc(plat_specific=1))
inc_dirs.insert(0, get_numpy_include_dirs())
# C libraries
c_misc_src = [join('c_misc', '*.c')]
c_misc_hdr = [join('c_misc', '*.h')]
cephes_src = [join('cephes', '*.c')]
cephes_hdr = [join('cephes', '*.h')]
config.add_library('sc_c_misc',
sources=c_misc_src,
include_dirs=[curdir] + inc_dirs,
depends=(cephes_hdr + cephes_src + c_misc_hdr +
cephes_hdr + ['*.h']),
macros=define_macros)
config.add_library('sc_cephes',
sources=cephes_src,
include_dirs=[curdir] + inc_dirs,
depends=(cephes_hdr + ['*.h']),
macros=define_macros)
# Fortran/C++ libraries
mach_src = [join('mach', '*.f')]
amos_src = [join('amos', '*.f')]
cdf_src = [join('cdflib', '*.f')]
specfun_src = [join('specfun', '*.f')]
config.add_library('sc_mach',
sources=mach_src,
config_fc={'noopt': (__file__, 1)})
config.add_library('sc_amos', sources=amos_src)
config.add_library('sc_cdf', sources=cdf_src)
config.add_library('sc_specfun', sources=specfun_src)
# Extension specfun
config.add_extension('specfun',
sources=['specfun.pyf'],
f2py_options=['--no-wrap-functions'],
depends=specfun_src,
define_macros=[],
libraries=['sc_specfun'])
# Extension _ufuncs
headers = ['*.h', join('c_misc', '*.h'), join('cephes', '*.h')]
ufuncs_src = [
'_ufuncs.c', 'sf_error.c', '_logit.c.src', "amos_wrappers.c",
"cdf_wrappers.c", "specfun_wrappers.c"
]
ufuncs_dep = (headers + ufuncs_src + amos_src + c_misc_src + cephes_src +
mach_src + cdf_src + specfun_src)
cfg = dict(get_system_info('lapack_opt'))
cfg.setdefault('include_dirs',
[]).extend([curdir] + inc_dirs + [numpy.get_include()])
cfg.setdefault('libraries', []).extend([
'sc_amos', 'sc_c_misc', 'sc_cephes', 'sc_mach', 'sc_cdf', 'sc_specfun'
])
cfg.setdefault('define_macros', []).extend(define_macros)
config.add_extension('_ufuncs',
depends=ufuncs_dep,
sources=ufuncs_src,
extra_info=get_info("npymath"),
**cfg)
# Extension _ufuncs_cxx
ufuncs_cxx_src = [
'_ufuncs_cxx.cxx', 'sf_error.c', '_faddeeva.cxx', 'Faddeeva.cc'
]
ufuncs_cxx_dep = (headers + ufuncs_cxx_src + cephes_src + ['*.hh'])
config.add_extension('_ufuncs_cxx',
sources=ufuncs_cxx_src,
depends=ufuncs_cxx_dep,
include_dirs=[curdir],
define_macros=define_macros,
extra_info=get_info("npymath"))
cfg = dict(get_system_info('lapack_opt'))
config.add_extension('_ellip_harm_2',
sources=[
'_ellip_harm_2.c',
'sf_error.c',
],
**cfg)
# combinatoris
config.add_extension('_comb', sources=['_comb.c'])
config.add_data_files('tests/*.py')
config.add_data_files('tests/data/README')
config.add_data_files('tests/data/*.npz')
config.add_subpackage('_precompute')
config.add_data_files('_precompute/tests/*.py')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.ccompiler_opt import NPY_CXX_FLAGS
from numpy.distutils.system_info import get_info, system_info
config = Configuration('linalg', parent_package, top_path)
config.add_subpackage('tests')
# Configure lapack_lite
src_dir = 'lapack_lite'
lapack_lite_src = [
os.path.join(src_dir, 'python_xerbla.c'),
os.path.join(src_dir, 'f2c_z_lapack.c'),
os.path.join(src_dir, 'f2c_c_lapack.c'),
os.path.join(src_dir, 'f2c_d_lapack.c'),
os.path.join(src_dir, 'f2c_s_lapack.c'),
os.path.join(src_dir, 'f2c_lapack.c'),
os.path.join(src_dir, 'f2c_blas.c'),
os.path.join(src_dir, 'f2c_config.c'),
os.path.join(src_dir, 'f2c.c'),
]
all_sources = config.paths(lapack_lite_src)
if os.environ.get('NPY_USE_BLAS_ILP64', "0") != "0":
lapack_info = get_info('lapack_ilp64_opt', 2)
else:
lapack_info = get_info('lapack_opt', 0) # and {}
use_lapack_lite = not lapack_info
if use_lapack_lite:
# This makes numpy.distutils write the fact that lapack_lite
# is being used to numpy.__config__
class numpy_linalg_lapack_lite(system_info):
def calc_info(self):
info = {'language': 'c'}
size_t_size = sysconfig.get_config_var("SIZEOF_SIZE_T")
if size_t_size:
maxsize = 2**(size_t_size - 1) - 1
else:
# We prefer using sysconfig as it allows cross-compilation
# but the information may be missing (e.g. on windows).
maxsize = sys.maxsize
if maxsize > 2**32:
# Build lapack-lite in 64-bit integer mode.
# The suffix is arbitrary (lapack_lite symbols follow it),
# but use the "64_" convention here.
info['define_macros'] = [('HAVE_BLAS_ILP64', None),
('BLAS_SYMBOL_SUFFIX', '64_')]
self.set_info(**info)
lapack_info = numpy_linalg_lapack_lite().get_info(2)
def get_lapack_lite_sources(ext, build_dir):
if use_lapack_lite:
print("### Warning: Using unoptimized lapack ###")
return all_sources
else:
if sys.platform == 'win32':
print("### Warning: python_xerbla.c is disabled ###")
return []
return [all_sources[0]]
config.add_extension(
'lapack_lite',
sources=['lapack_litemodule.c', get_lapack_lite_sources],
depends=['lapack_lite/f2c.h'],
extra_info=lapack_info,
)
# umath_linalg module
config.add_extension(
'_umath_linalg',
sources=['umath_linalg.cpp', get_lapack_lite_sources],
depends=['lapack_lite/f2c.h'],
extra_info=lapack_info,
extra_cxx_compile_args=NPY_CXX_FLAGS,
libraries=['npymath'],
)
config.add_data_files('*.pyi')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('ma', parent_package, top_path)
config.add_subpackage('tests')
config.add_data_files('*.pyi')
return config
def configuration(parent_package='', top_path=None):
import os.path as op
from numpy.distutils.misc_util import Configuration
from sfepy import Config
site_config = Config()
os_flag = {'posix': 0, 'windows': 1}
auto_dir = op.dirname(__file__)
auto_name = op.split(auto_dir)[-1]
config = Configuration(auto_name, parent_package, top_path)
defines = [('__SDIR__', "'\"%s\"'" % auto_dir),
('SFEPY_PLATFORM', os_flag[site_config.system()])]
if '-DDEBUG_FMF' in site_config.debug_flags():
defines.append(('DEBUG_FMF', None))
if '-DDEBUG_MESH' in site_config.debug_flags():
defines.append(('DEBUG_MESH', None))
common_src = ['fmfield.c', 'refmaps.c', 'geommech.c', 'common_python.c']
config.add_library('sfepy_common',
sources=common_src,
extra_compiler_args=site_config.compile_flags(),
extra_link_args=site_config.link_flags(),
include_dirs=[auto_dir,
site_config.python_include()],
macros=defines)
src = ['_fmfield.pyx']
config.add_extension('_fmfield',
sources=src,
libraries=['sfepy_common'],
depends=common_src,
extra_compile_args=site_config.compile_flags(),
extra_link_args=site_config.link_flags(),
include_dirs=[auto_dir],
define_macros=defines)
src = ['mappings.pyx']
config.add_extension('mappings',
sources=src,
libraries=['sfepy_common'],
depends=common_src,
extra_compile_args=site_config.compile_flags(),
extra_link_args=site_config.link_flags(),
include_dirs=[auto_dir],
define_macros=defines)
src = ['assemble.pyx']
config.add_extension('assemble',
sources=src,
extra_compile_args=site_config.compile_flags(),
extra_link_args=site_config.link_flags(),
include_dirs=[auto_dir],
define_macros=defines)
src = [
'cmesh.pyx', 'geomtrans.c', 'mesh.c', 'meshutils.c', 'sort.c',
'common_python.c'
]
config.add_extension('cmesh',
sources=src,
extra_compile_args=site_config.compile_flags(),
extra_link_args=site_config.link_flags(),
include_dirs=[auto_dir],
define_macros=defines)
src = ['crefcoors.pyx', 'refcoors.c', 'geomtrans.c', 'mesh.c']
config.add_extension('crefcoors',
sources=src,
libraries=['sfepy_common'],
depends=common_src,
extra_compile_args=site_config.compile_flags(),
extra_link_args=site_config.link_flags(),
include_dirs=[auto_dir],
define_macros=defines)
src = ['_geommech.pyx']
config.add_extension('_geommech',
sources=src,
libraries=['sfepy_common'],
extra_compile_args=site_config.compile_flags(),
extra_link_args=site_config.link_flags(),
include_dirs=[auto_dir],
define_macros=defines)
# Include *.pxd files in distribution tarball and install them along
# with the extension modules.
pxd_files = [
'cmesh.pxd', 'mappings.pxd', 'types.pxd', '_fmfield.pxd',
'_geommech.pxd'
]
config.add_data_files(('', pxd_files))
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('graph', parent_package, top_path)
config.add_data_dir('tests')
config.add_data_files('balance-rgb.txt')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('special', parent_package, top_path)
define_macros = []
if sys.platform == 'win32':
# define_macros.append(('NOINFINITIES',None))
# define_macros.append(('NONANS',None))
define_macros.append(('_USE_MATH_DEFINES', None))
curdir = os.path.abspath(os.path.dirname(__file__))
# C libraries
config.add_library(
'sc_c_misc',
sources=[join('c_misc', '*.c')],
include_dirs=[curdir,
get_python_inc(),
get_numpy_include_dirs()],
macros=define_macros)
config.add_library(
'sc_cephes',
sources=[join('cephes', '*.c')],
include_dirs=[curdir,
get_python_inc(),
get_numpy_include_dirs()],
macros=define_macros)
# Fortran/C++ libraries
config.add_library('sc_mach',
sources=[join('mach', '*.f')],
config_fc={'noopt': (__file__, 1)})
config.add_library('sc_amos', sources=[join('amos', '*.f')])
config.add_library('sc_cdf', sources=[join('cdflib', '*.f')])
config.add_library('sc_specfun', sources=[join('specfun', '*.f')])
# Extension specfun
config.add_extension('specfun',
sources=['specfun.pyf'],
f2py_options=['--no-wrap-functions'],
define_macros=[],
libraries=['sc_specfun'])
# Extension _ufuncs
config.add_extension('_ufuncs',
libraries=[
'sc_amos', 'sc_c_misc', 'sc_cephes', 'sc_mach',
'sc_cdf', 'sc_specfun'
],
depends=[
"_logit.h", "cephes.h", "amos_wrappers.h",
"cdf_wrappers.h", "specfun_wrappers.h",
"c_misc/misc.h", "cephes/mconf.h",
"cephes/cephes_names.h"
],
sources=[
'_ufuncs.c', 'sf_error.c', '_logit.c.src',
"amos_wrappers.c", "cdf_wrappers.c",
"specfun_wrappers.c"
],
include_dirs=[curdir],
define_macros=define_macros,
extra_info=get_info("npymath"))
# Extension _ufuncs_cxx
config.add_extension('_ufuncs_cxx',
sources=[
'_ufuncs_cxx.cxx',
'sf_error.c',
'_faddeeva.cxx',
'Faddeeva.cc',
],
libraries=['sc_cephes'],
include_dirs=[curdir],
define_macros=define_macros,
extra_info=get_info("npymath"))
config.add_data_files('tests/*.py')
config.add_data_files('tests/data/README')
config.add_data_files('tests/data/*.npz')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs
from numpy.distutils.misc_util import get_info as get_misc_info
from scipy._build_utils.system_info import get_info as get_sys_info
from distutils.sysconfig import get_python_inc
config = Configuration('spatial', parent_package, top_path)
config.add_data_dir('tests')
# spatial.transform
config.add_subpackage('transform')
# qhull
qhull_src = sorted(
glob.glob(join(dirname(__file__), 'qhull_src', 'src', '*.c')))
inc_dirs = [get_python_inc()]
if inc_dirs[0] != get_python_inc(plat_specific=1):
inc_dirs.append(get_python_inc(plat_specific=1))
inc_dirs.append(get_numpy_include_dirs())
inc_dirs.append(join(dirname(dirname(__file__)), '_lib'))
cfg = dict(get_sys_info('lapack_opt'))
cfg.setdefault('include_dirs', []).extend(inc_dirs)
config.add_extension('qhull', sources=['qhull.c'] + qhull_src, **cfg)
# cKDTree
ckdtree_src = [
'query.cxx', 'build.cxx', 'globals.cxx', 'cpp_exc.cxx',
'query_pairs.cxx', 'count_neighbors.cxx', 'query_ball_point.cxx',
'query_ball_tree.cxx', 'sparse_distances.cxx'
]
ckdtree_src = [join('ckdtree', 'src', x) for x in ckdtree_src]
ckdtree_headers = [
'ckdtree_decl.h', 'ckdtree_methods.h', 'coo_entries.h', 'cpp_exc.h',
'cpp_utils.h', 'distance_base.h', 'distance.h', 'ordered_pair.h',
'partial_sort.h', 'rectangle.h'
]
ckdtree_headers = [join('ckdtree', 'src', x) for x in ckdtree_headers]
ckdtree_dep = ['ckdtree.cxx'] + ckdtree_headers + ckdtree_src
config.add_extension('ckdtree',
sources=['ckdtree.cxx'] + ckdtree_src,
depends=ckdtree_dep,
include_dirs=inc_dirs + [join('ckdtree', 'src')])
# _distance_wrap
config.add_extension('_distance_wrap',
sources=[join('src', 'distance_wrap.c')],
depends=[join('src', 'distance_impl.h')],
include_dirs=[get_numpy_include_dirs()],
extra_info=get_misc_info("npymath"))
config.add_extension('_voronoi', sources=['_voronoi.c'])
config.add_extension('_hausdorff', sources=['_hausdorff.c'])
# Add license files
config.add_data_files('qhull_src/COPYING.txt')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, dot_join
from numpy.distutils.system_info import get_info, default_lib_dirs
config = Configuration('core', parent_package, top_path)
local_dir = config.local_path
codegen_dir = join(local_dir, 'code_generators')
generate_umath_py = join(codegen_dir, 'generate_umath.py')
n = dot_join(config.name, 'generate_umath')
generate_umath = imp.load_module('_'.join(n.split('.')),
open(generate_umath_py, 'U'),
generate_umath_py, ('.py', 'U', 1))
header_dir = 'include/numpy' # this is relative to config.path_in_package
def generate_config_h(ext, build_dir):
target = join(build_dir, header_dir, 'config.h')
dir = os.path.dirname(target)
if not os.path.exists(dir):
os.makedirs(dir)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
tc = generate_testcode(target)
from distutils import sysconfig
python_include = sysconfig.get_python_inc()
python_h = join(python_include, 'Python.h')
if not os.path.isfile(python_h):
raise SystemError,\
"Non-existing %s. Perhaps you need to install"\
" python-dev|python-devel." % (python_h)
result = config_cmd.try_run(tc,
include_dirs=[python_include],
library_dirs=default_lib_dirs)
if not result:
raise SystemError,"Failed to test configuration. "\
"See previous error messages for more information."
moredefs = []
#
mathlibs = []
tc = testcode_mathlib()
mathlibs_choices = [[], ['m'], ['cpml']]
mathlib = os.environ.get('MATHLIB')
if mathlib:
mathlibs_choices.insert(0, mathlib.split(','))
for libs in mathlibs_choices:
if config_cmd.try_run(tc, libraries=libs):
mathlibs = libs
break
else:
raise EnvironmentError("math library missing; rerun "
"setup.py after setting the "
"MATHLIB env variable")
ext.libraries.extend(mathlibs)
moredefs.append(('MATHLIB', ','.join(mathlibs)))
def check_func(func_name):
return config_cmd.check_func(func_name,
libraries=mathlibs,
decl=False,
headers=['math.h'])
for func_name, defsymbol in FUNCTIONS_TO_CHECK:
if check_func(func_name):
moredefs.append(defsymbol)
if is_npy_no_signal():
moredefs.append('__NPY_PRIVATE_NO_SIGNAL')
if sys.platform == 'win32' or os.name == 'nt':
from numpy.distutils.misc_util import get_build_architecture
a = get_build_architecture()
print 'BUILD_ARCHITECTURE: %r, os.name=%r, sys.platform=%r' % (
a, os.name, sys.platform)
if a == 'AMD64':
moredefs.append('DISTUTILS_USE_SDK')
if sys.version[:3] < '2.4':
if config_cmd.check_func('strtod',
decl=False,
headers=['stdlib.h']):
moredefs.append(('PyOS_ascii_strtod', 'strtod'))
target_f = open(target, 'a')
for d in moredefs:
if isinstance(d, str):
target_f.write('#define %s\n' % (d))
else:
target_f.write('#define %s %s\n' % (d[0], d[1]))
target_f.close()
print 'File:', target
target_f = open(target)
print target_f.read()
target_f.close()
print 'EOF'
else:
mathlibs = []
target_f = open(target)
for line in target_f.readlines():
s = '#define MATHLIB'
if line.startswith(s):
value = line[len(s):].strip()
if value:
mathlibs.extend(value.split(','))
target_f.close()
ext.libraries.extend(mathlibs)
incl_dir = os.path.dirname(target)
if incl_dir not in config.numpy_include_dirs:
config.numpy_include_dirs.append(incl_dir)
return target
def generate_numpyconfig_h(ext, build_dir):
"""Depends on config.h: generate_config_h has to be called before !"""
target = join(build_dir, header_dir, 'numpyconfig.h')
dir = os.path.dirname(target)
if not os.path.exists(dir):
os.makedirs(dir)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
testcode = generate_numpyconfig_code(target)
from distutils import sysconfig
python_include = sysconfig.get_python_inc()
python_h = join(python_include, 'Python.h')
if not os.path.isfile(python_h):
raise SystemError,\
"Non-existing %s. Perhaps you need to install"\
" python-dev|python-devel." % (python_h)
config.numpy_include_dirs
result = config_cmd.try_run(testcode,
include_dirs = [python_include] + \
config.numpy_include_dirs,
library_dirs = default_lib_dirs)
if not result:
raise SystemError,"Failed to generate numpy configuration. "\
"See previous error messages for more information."
print 'File: %s' % target
target_f = open(target)
print target_f.read()
target_f.close()
print 'EOF'
config.add_data_files((header_dir, target))
return target
def generate_api_func(module_name):
def generate_api(ext, build_dir):
script = join(codegen_dir, module_name + '.py')
sys.path.insert(0, codegen_dir)
try:
m = __import__(module_name)
log.info('executing %s', script)
h_file, c_file, doc_file = m.generate_api(
os.path.join(build_dir, header_dir))
finally:
del sys.path[0]
config.add_data_files((header_dir, h_file), (header_dir, doc_file))
return (h_file, )
return generate_api
generate_array_api = generate_api_func('generate_array_api')
generate_ufunc_api = generate_api_func('generate_ufunc_api')
def generate_umath_c(ext, build_dir):
target = join(build_dir, header_dir, '__umath_generated.c')
dir = os.path.dirname(target)
if not os.path.exists(dir):
os.makedirs(dir)
script = generate_umath_py
if newer(script, target):
f = open(target, 'w')
f.write(
generate_umath.make_code(generate_umath.defdict,
generate_umath.__file__))
f.close()
return []
config.add_data_files('include/numpy/*.h')
config.add_include_dirs('src')
config.numpy_include_dirs.extend(config.paths('include'))
deps = [
join('src', 'arrayobject.c'),
join('src', 'arraymethods.c'),
join('src', 'scalartypes.inc.src'),
join('src', 'arraytypes.inc.src'),
join('src', '_signbit.c'),
join('src', '_isnan.c'),
join('src', 'ucsnarrow.c'),
join('include', 'numpy', '*object.h'), 'include/numpy/fenv/fenv.c',
'include/numpy/fenv/fenv.h',
join(codegen_dir, 'genapi.py'),
join(codegen_dir, '*.txt')
]
# Don't install fenv unless we need them.
if sys.platform == 'cygwin':
config.add_data_dir('include/numpy/fenv')
config.add_extension(
'multiarray',
sources=[
join('src', 'multiarraymodule.c'), generate_config_h,
generate_numpyconfig_h, generate_array_api,
join('src', 'scalartypes.inc.src'),
join('src', 'arraytypes.inc.src'),
join(codegen_dir, 'generate_array_api.py'),
join('*.py')
],
depends=deps,
)
config.add_extension(
'umath',
sources=[
generate_config_h,
generate_numpyconfig_h,
join('src', 'umathmodule.c.src'),
generate_umath_c,
generate_ufunc_api,
join('src', 'scalartypes.inc.src'),
join('src', 'arraytypes.inc.src'),
],
depends=[
join('src', 'ufuncobject.c'),
generate_umath_py,
join(codegen_dir, 'generate_ufunc_api.py'),
] + deps,
)
config.add_extension(
'_sort',
sources=[
join('src', '_sortmodule.c.src'),
generate_config_h,
generate_numpyconfig_h,
generate_array_api,
],
)
config.add_extension(
'scalarmath',
sources=[
join('src', 'scalarmathmodule.c.src'), generate_config_h,
generate_numpyconfig_h, generate_array_api, generate_ufunc_api
],
)
# Configure blasdot
blas_info = get_info('blas_opt', 0)
#blas_info = {}
def get_dotblas_sources(ext, build_dir):
if blas_info:
if ('NO_ATLAS_INFO', 1) in blas_info.get('define_macros', []):
return None # dotblas needs ATLAS, Fortran compiled blas will not be sufficient.
return ext.depends[:1]
return None # no extension module will be built
config.add_extension('_dotblas',
sources=[get_dotblas_sources],
depends=[
join('blasdot', '_dotblas.c'),
join('blasdot', 'cblas.h'),
],
include_dirs=['blasdot'],
extra_info=blas_info)
config.add_data_dir('tests')
config.add_data_dir('tests/data')
config.make_svn_version_py()
return config
def configuration(parent_package='', top_path=''):
from numpy.distutils.misc_util import Configuration
config = Configuration(None, parent_package, top_path)
pkglist = setuptools.find_packages()
print(pkglist)
for i in pkglist:
config.add_subpackage(i)
config.add_data_files(['.', ['AUTHORS']])
config.add_data_files(
join('holopy', 'scattering', 'tests', 'gold', 'full_data', '*.h5'))
config.add_data_files(
join('holopy', 'scattering', 'tests', 'gold', '*.yaml'))
config.add_data_files(
join('holopy', 'core', 'tests', 'exampledata', '*.h5'))
config.add_data_files(
join('holopy', 'core', 'tests', 'exampledata', '*.jpg'))
config.add_data_files(
join('holopy', 'propagation', 'tests', 'gold', 'full_data', '*.h5'))
config.add_data_files(
join('holopy', 'propagation', 'tests', 'gold', '*.yaml'))
config.add_data_files(join(tmat_dir, tmat_file))
config.get_version()
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info
config = Configuration('optimize',parent_package, top_path)
minpack_src = [join('minpack','*f')]
config.add_library('minpack',sources=minpack_src)
config.add_extension('_minpack',
sources=['_minpackmodule.c'],
libraries=['minpack'],
depends=(["minpack.h","__minpack.h"]
+ minpack_src),
**numpy_nodepr_api)
rootfind_src = [join('Zeros','*.c')]
rootfind_hdr = [join('Zeros','zeros.h')]
config.add_library('rootfind',
sources=rootfind_src,
headers=rootfind_hdr,
**numpy_nodepr_api)
config.add_extension('_zeros',
sources=['zeros.c'],
libraries=['rootfind'],
depends=(rootfind_src + rootfind_hdr),
**numpy_nodepr_api)
lapack = get_info('lapack_opt')
if 'define_macros' in numpy_nodepr_api:
if ('define_macros' in lapack) and (lapack['define_macros'] is not None):
lapack['define_macros'] = (lapack['define_macros'] +
numpy_nodepr_api['define_macros'])
else:
lapack['define_macros'] = numpy_nodepr_api['define_macros']
sources = ['lbfgsb.pyf', 'lbfgsb.f', 'linpack.f', 'timer.f']
config.add_extension('_lbfgsb',
sources=[join('lbfgsb',x) for x in sources],
**lapack)
sources = ['moduleTNC.c','tnc.c']
config.add_extension('moduleTNC',
sources=[join('tnc',x) for x in sources],
depends=[join('tnc','tnc.h')],
**numpy_nodepr_api)
config.add_extension('_cobyla',
sources=[join('cobyla',x) for x in ['cobyla.pyf',
'cobyla2.f',
'trstlp.f']],
**numpy_nodepr_api)
sources = ['minpack2.pyf', 'dcsrch.f', 'dcstep.f']
config.add_extension('minpack2',
sources=[join('minpack2',x) for x in sources],
**numpy_nodepr_api)
sources = ['slsqp.pyf', 'slsqp_optmz.f']
config.add_extension('_slsqp', sources=[join('slsqp', x) for x in sources],
**numpy_nodepr_api)
config.add_extension('_nnls', sources=[join('nnls', x)
for x in ["nnls.f","nnls.pyf"]],
**numpy_nodepr_api)
config.add_extension('_group_columns', sources=['_group_columns.c'],)
config.add_subpackage('_lsq')
config.add_subpackage('_trlib')
config.add_subpackage('_trustregion_constr')
config.add_data_dir('tests')
# Add license files
config.add_data_files('lbfgsb/README')
return config
sdkdir = os.environ.get('WindowsSdkDir')
if sdkdir:
include_dirs.append(os.path.join(sdkdir, 'Include'))
library_dirs.append(os.path.join(sdkdir, 'Lib'))
# make sure we have mt.exe available in case we need it
path = os.environ['PATH'].split(';')
path.append(os.path.join(sdkdir, 'bin'))
os.environ['PATH'] = ';'.join(path)
config = Configuration(name='slsqp')
config.add_extension('slsqp',
sources=['*.f', 'f2py/slsqp.pyf'],
include_dirs=include_dirs,
library_dirs=library_dirs)
config.add_data_files('LICENSE', 'README')
kwds = {
'install_requires': ['numpy'],
'version': '1.0.2',
'zip_safe': False,
'license': 'permissive open source',
# NOTE: we use 'url' here, but it really translates to 'home-page'
# in the metadata. Go figure.
'url': 'http://www.pyopt.org',
'package_data': {
'openmdao.main': ['*.html']
},
}
kwds.update(config.todict())
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, dot_join
from numpy.distutils.command.scons import get_scons_pkg_build_dir
from numpy.distutils.system_info import get_info, default_lib_dirs
config = Configuration('core', parent_package, top_path)
local_dir = config.local_path
header_dir = 'include/numpy' # this is relative to config.path_in_package
config.add_subpackage('code_generators')
# List of files to register to numpy.distutils
dot_blas_src = [join('blasdot', '_dotblas.c'), join('blasdot', 'cblas.h')]
api_definition = [
join('code_generators', 'array_api_order.txt'),
join('code_generators', 'multiarray_api_order.txt'),
join('code_generators', 'ufunc_api_order.txt')
]
core_src = [
join('src', basename(i))
for i in glob.glob(join(local_dir, 'src', '*.c'))
]
core_src += [
join('src', basename(i))
for i in glob.glob(join(local_dir, 'src', '*.src'))
]
source_files = dot_blas_src + api_definition + core_src + \
[join(header_dir, 'numpyconfig.h.in')]
# Add generated files to distutils...
def add_config_header():
scons_build_dir = get_scons_build_dir()
# XXX: I really have to think about how to communicate path info
# between scons and distutils, and set the options at one single
# location.
target = join(get_scons_pkg_build_dir(config.name), 'config.h')
incl_dir = os.path.dirname(target)
if incl_dir not in config.numpy_include_dirs:
config.numpy_include_dirs.append(incl_dir)
def add_numpyconfig_header():
scons_build_dir = get_scons_build_dir()
# XXX: I really have to think about how to communicate path info
# between scons and distutils, and set the options at one single
# location.
target = join(get_scons_pkg_build_dir(config.name),
'include/numpy/numpyconfig.h')
incl_dir = os.path.dirname(target)
if incl_dir not in config.numpy_include_dirs:
config.numpy_include_dirs.append(incl_dir)
config.add_data_files((header_dir, target))
def add_array_api():
scons_build_dir = get_scons_build_dir()
# XXX: I really have to think about how to communicate path info
# between scons and distutils, and set the options at one single
# location.
h_file = join(get_scons_pkg_build_dir(config.name),
'__multiarray_api.h')
t_file = join(get_scons_pkg_build_dir(config.name),
'multiarray_api.txt')
config.add_data_files((header_dir, h_file), (header_dir, t_file))
def add_ufunc_api():
scons_build_dir = get_scons_build_dir()
# XXX: I really have to think about how to communicate path info
# between scons and distutils, and set the options at one single
# location.
h_file = join(get_scons_pkg_build_dir(config.name), '__ufunc_api.h')
t_file = join(get_scons_pkg_build_dir(config.name), 'ufunc_api.txt')
config.add_data_files((header_dir, h_file), (header_dir, t_file))
def add_generated_files(*args, **kw):
add_config_header()
add_numpyconfig_header()
add_array_api()
add_ufunc_api()
config.add_sconscript('SConstruct',
post_hook=add_generated_files,
source_files=source_files)
config.add_data_files('include/numpy/*.h')
config.add_include_dirs('src')
config.numpy_include_dirs.extend(config.paths('include'))
# Don't install fenv unless we need them.
if sys.platform == 'cygwin':
config.add_data_dir('include/numpy/fenv')
config.add_data_dir('tests')
config.make_svn_version_py()
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from scipy._build_utils.system_info import get_info
from scipy._build_utils import (gfortran_legacy_flag_hook,
blas_ilp64_pre_build_hook, combine_dict,
uses_blas64, get_f2py_int64_options)
from scipy._build_utils.compiler_helper import (set_cxx_flags_hook,
set_cxx_flags_clib_hook,
set_c_flags_hook)
config = Configuration('optimize', parent_package, top_path)
include_dirs = [join(os.path.dirname(__file__), '..', '_lib', 'src')]
minpack_src = [join('minpack', '*f')]
config.add_library('minpack', sources=minpack_src)
config.add_extension('_minpack',
sources=['_minpackmodule.c'],
libraries=['minpack'],
depends=(["minpack.h", "__minpack.h"] + minpack_src),
include_dirs=include_dirs,
**numpy_nodepr_api)
config.add_library('rectangular_lsap',
sources='rectangular_lsap/rectangular_lsap.cpp',
headers='rectangular_lsap/rectangular_lsap.h',
_pre_build_hook=set_cxx_flags_clib_hook)
_lsap = config.add_extension('_lsap_module',
sources=['_lsap_module.c'],
libraries=['rectangular_lsap'],
depends=([
'rectangular_lsap/rectangular_lsap.cpp',
'rectangular_lsap/rectangular_lsap.h'
]),
include_dirs=include_dirs,
**numpy_nodepr_api)
_lsap._pre_build_hook = set_c_flags_hook
rootfind_src = [join('Zeros', '*.c')]
rootfind_hdr = [join('Zeros', 'zeros.h')]
config.add_library('rootfind',
sources=rootfind_src,
headers=rootfind_hdr,
**numpy_nodepr_api)
config.add_extension('_zeros',
sources=['zeros.c'],
libraries=['rootfind'],
depends=(rootfind_src + rootfind_hdr),
**numpy_nodepr_api)
if uses_blas64():
lapack = get_info('lapack_ilp64_opt')
f2py_options = get_f2py_int64_options()
pre_build_hook = blas_ilp64_pre_build_hook(lapack)
else:
lapack = get_info('lapack_opt')
f2py_options = None
pre_build_hook = None
lapack = combine_dict(lapack, numpy_nodepr_api)
sources = ['lbfgsb.pyf', 'lbfgsb.f', 'linpack.f', 'timer.f']
ext = config.add_extension(
'_lbfgsb',
sources=[join('lbfgsb_src', x) for x in sources],
f2py_options=f2py_options,
**lapack)
ext._pre_build_hook = pre_build_hook
sources = ['moduleTNC.c', 'tnc.c']
config.add_extension('moduleTNC',
sources=[join('tnc', x) for x in sources],
depends=[join('tnc', 'tnc.h')],
**numpy_nodepr_api)
config.add_extension('_cobyla',
sources=[
join('cobyla', x)
for x in ['cobyla.pyf', 'cobyla2.f', 'trstlp.f']
],
**numpy_nodepr_api)
sources = ['minpack2.pyf', 'dcsrch.f', 'dcstep.f']
config.add_extension('minpack2',
sources=[join('minpack2', x) for x in sources],
**numpy_nodepr_api)
sources = ['slsqp.pyf', 'slsqp_optmz.f']
ext = config.add_extension('_slsqp',
sources=[join('slsqp', x) for x in sources],
**numpy_nodepr_api)
ext._pre_build_hook = gfortran_legacy_flag_hook
config.add_data_files('__nnls.pyi')
ext = config.add_extension(
'__nnls',
sources=[join('__nnls', x) for x in ["nnls.f", "nnls.pyf"]],
**numpy_nodepr_api)
ext._pre_build_hook = gfortran_legacy_flag_hook
if int(os.environ.get('SCIPY_USE_PYTHRAN', 0)):
import pythran
ext = pythran.dist.PythranExtension(
'scipy.optimize._group_columns',
sources=["scipy/optimize/_group_columns.py"],
config=['compiler.blas=none'])
config.ext_modules.append(ext)
else:
config.add_extension(
'_group_columns',
sources=['_group_columns.c'],
)
config.add_extension('_bglu_dense', sources=['_bglu_dense.c'])
config.add_subpackage('_lsq')
config.add_subpackage('_trlib')
config.add_subpackage('_trustregion_constr')
# Cython optimize API for zeros functions
config.add_subpackage('cython_optimize')
config.add_data_files('cython_optimize.pxd')
config.add_data_files(os.path.join('cython_optimize', '*.pxd'))
config.add_extension('cython_optimize._zeros',
sources=[os.path.join('cython_optimize', '_zeros.c')])
config.add_subpackage('_shgo_lib')
config.add_data_dir('_shgo_lib')
# HiGHS linear programming libraries and extensions
config.add_subpackage('_highs')
config.add_data_dir('tests')
# Add license files
config.add_data_files('lbfgsb_src/README')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from scipy._build_utils.system_info import get_info
config = Configuration('optimize', parent_package, top_path)
include_dirs = [join(os.path.dirname(__file__), '..', '_lib', 'src')]
minpack_src = [join('minpack', '*f')]
config.add_library('minpack', sources=minpack_src)
config.add_extension('_minpack',
sources=['_minpackmodule.c'],
libraries=['minpack'],
depends=(["minpack.h", "__minpack.h"] + minpack_src),
include_dirs=include_dirs,
**numpy_nodepr_api)
config.add_library('rectangular_lsap',
sources='rectangular_lsap/rectangular_lsap.cpp',
headers='rectangular_lsap/rectangular_lsap.h')
config.add_extension('_lsap_module',
sources=['_lsap_module.c'],
libraries=['rectangular_lsap'],
depends=([
'rectangular_lsap/rectangular_lsap.cpp',
'rectangular_lsap/rectangular_lsap.h'
]),
include_dirs=include_dirs,
**numpy_nodepr_api)
rootfind_src = [join('Zeros', '*.c')]
rootfind_hdr = [join('Zeros', 'zeros.h')]
config.add_library('rootfind',
sources=rootfind_src,
headers=rootfind_hdr,
**numpy_nodepr_api)
config.add_extension('_zeros',
sources=['zeros.c'],
libraries=['rootfind'],
depends=(rootfind_src + rootfind_hdr),
**numpy_nodepr_api)
lapack = get_info('lapack_opt')
if 'define_macros' in numpy_nodepr_api:
if ('define_macros' in lapack) and (lapack['define_macros']
is not None):
lapack['define_macros'] = (lapack['define_macros'] +
numpy_nodepr_api['define_macros'])
else:
lapack['define_macros'] = numpy_nodepr_api['define_macros']
sources = ['lbfgsb.pyf', 'lbfgsb.f', 'linpack.f', 'timer.f']
config.add_extension('_lbfgsb',
sources=[join('lbfgsb_src', x) for x in sources],
**lapack)
sources = ['moduleTNC.c', 'tnc.c']
config.add_extension('moduleTNC',
sources=[join('tnc', x) for x in sources],
depends=[join('tnc', 'tnc.h')],
**numpy_nodepr_api)
config.add_extension('_cobyla',
sources=[
join('cobyla', x)
for x in ['cobyla.pyf', 'cobyla2.f', 'trstlp.f']
],
**numpy_nodepr_api)
sources = ['minpack2.pyf', 'dcsrch.f', 'dcstep.f']
config.add_extension('minpack2',
sources=[join('minpack2', x) for x in sources],
**numpy_nodepr_api)
sources = ['slsqp.pyf', 'slsqp_optmz.f']
config.add_extension('_slsqp',
sources=[join('slsqp', x) for x in sources],
**numpy_nodepr_api)
config.add_extension(
'_nnls',
sources=[join('nnls', x) for x in ["nnls.f", "nnls.pyf"]],
**numpy_nodepr_api)
config.add_extension(
'_group_columns',
sources=['_group_columns.c'],
)
config.add_extension('_bglu_dense', sources=['_bglu_dense.c'])
config.add_subpackage('_lsq')
config.add_subpackage('_trlib')
config.add_subpackage('_trustregion_constr')
# Cython optimize API for zeros functions
config.add_subpackage('cython_optimize')
config.add_data_files('cython_optimize.pxd')
config.add_data_files(os.path.join('cython_optimize', '*.pxd'))
config.add_extension('cython_optimize._zeros',
sources=[os.path.join('cython_optimize', '_zeros.c')])
config.add_subpackage('_shgo_lib')
config.add_data_dir('_shgo_lib')
config.add_data_dir('tests')
# Add license files
config.add_data_files('lbfgsb_src/README')
return config
def configuration(parent_package='', top_path=None):
config = Configuration('f2py', parent_package, top_path)
config.add_data_dir('tests')
config.add_data_files('src/fortranobject.c', 'src/fortranobject.h')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('impl', parent_package, top_path)
randomdir = os.path.join(top_path, "lightning", "impl", "randomkit")
config.add_extension('adagrad_fast',
sources=['adagrad_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('dataset_fast',
sources=['dataset_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('dual_cd_fast',
sources=['dual_cd_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('loss_fast',
sources=['loss_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('prank_fast',
sources=['prank_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('primal_cd_fast',
sources=['primal_cd_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('prox_fast',
sources=['prox_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('sag_fast',
sources=['sag_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('sdca_fast',
sources=['sdca_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('sgd_fast',
sources=['sgd_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_extension('svrg_fast',
sources=['svrg_fast.pyx'],
language='c++',
include_dirs=[numpy.get_include(), randomdir])
config.add_subpackage('datasets')
config.add_subpackage('randomkit')
config.add_subpackage('tests')
# add .pxd files to be re-used by third party software
config.add_data_files('sag_fast.pxd', 'dataset_fast.pxd', 'sgd_fast.pxd',
'prox_fast.pxd')
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('_highs', parent_package, top_path)
# HiGHS info
_major_dot_minor = _get_version('CMakeLists.txt', 'project(HIGHS VERSION',
'LANGUAGES CXX C')
HIGHS_VERSION_MAJOR, HIGHS_VERSION_MINOR = _major_dot_minor.split('.')
HIGHS_VERSION_PATCH = _get_version('CMakeLists.txt', 'HIGHS_VERSION_PATCH')
GITHASH = 'n/a'
HIGHS_DIR = str(_highs_dir().resolve())
# Here are the pound defines that HConfig.h would usually provide;
# We provide an empty HConfig.h file and do the defs and undefs
# here:
TODAY_DATE = datetime.today().strftime('%Y-%m-%d')
DEFINE_MACROS = [
('CMAKE_BUILD_TYPE', '"RELEASE"'),
('HIGHS_GITHASH', '"%s"' % GITHASH),
('HIGHS_COMPILATION_DATE', '"' + TODAY_DATE + '"'),
('HIGHS_VERSION_MAJOR', HIGHS_VERSION_MAJOR),
('HIGHS_VERSION_MINOR', HIGHS_VERSION_MINOR),
('HIGHS_VERSION_PATCH', HIGHS_VERSION_PATCH),
('HIGHS_DIR', '"' + HIGHS_DIR + '"'),
# ('NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION', None),
]
UNDEF_MACROS = [
'OPENMP', # unconditionally disable openmp
'EXT_PRESOLVE',
'SCIP_DEV',
'HiGHSDEV',
'OSI_FOUND',
]
# Compile BASICLU as a static library to appease clang:
# (won't allow -std=c++11/14 option for C sources)
basiclu_sources = _get_sources('src/CMakeLists.txt',
'set(basiclu_sources\n', ')')
highs_root = _highs_dir()
config.add_library(
'basiclu',
sources=basiclu_sources,
include_dirs=[
'src',
str(highs_root / 'src'),
str(highs_root / 'src/util'),
str(highs_root / 'extern'),
join(str(highs_root), 'src', 'ipm', 'basiclu', 'include'),
],
language='c',
macros=DEFINE_MACROS,
_pre_build_hook=basiclu_pre_build_hook,
)
# highs_wrapper:
ipx_sources = _get_sources('src/CMakeLists.txt', 'set(ipx_sources\n', ')')
highs_sources = _get_sources('src/CMakeLists.txt', 'set(sources\n', ')')
highs_sources += [str(highs_root / "src/ipm/IpxWrapper.cpp")]
ext = config.add_extension(
'_highs_wrapper',
sources=([join('cython', 'src', '_highs_wrapper.cxx')] +
highs_sources + ipx_sources),
include_dirs=[
# highs_wrapper
'src',
str(highs_root / 'src'),
str(highs_root / 'src/util'),
str(highs_root / 'extern'),
join(str(highs_root), 'cython', 'src'),
join(str(highs_root), 'src', 'lp_data'),
# highs
join(str(highs_root), 'src', 'io'),
join(str(highs_root), 'src', 'ipm', 'ipx', 'include'),
# IPX
join(str(highs_root), 'src', 'ipm', 'ipx', 'include'),
join(str(highs_root), 'src', 'ipm', 'basiclu', 'include'),
],
language='c++',
libraries=['basiclu'],
define_macros=DEFINE_MACROS,
undef_macros=UNDEF_MACROS,
depends=["setup.py"] + basiclu_sources + highs_sources + ipx_sources,
)
# Add c++11/14 support:
ext._pre_build_hook = pre_build_hook
# Export constants and enums from HiGHS:
ext = config.add_extension(
'_highs_constants',
sources=[join('cython', 'src', '_highs_constants.cxx')],
include_dirs=[
'src',
str(highs_root / 'src'),
str(highs_root / 'src/util'),
str(highs_root / 'extern'),
join(str(highs_root), 'cython', 'src'),
join(str(highs_root), 'src', 'io'),
join(str(highs_root), 'src', 'lp_data'),
join(str(highs_root), 'src', 'simplex'),
],
language='c++',
depends=["setup.py"],
)
ext._pre_build_hook = pre_build_hook
config.add_data_files(os.path.join('cython', 'src', '*.pxd'))
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import dict_append, get_info
agg_dir = 'agg-24'
agg_lib = 'agg24_src'
config = Configuration('agg', parent_package,top_path)
numerix_info = get_info('numerix')
if ('NUMPY', None) in numerix_info.get('define_macros',[]):
dict_append(numerix_info,
define_macros = [('PY_ARRAY_TYPES_PREFIX','NUMPY_CXX'),
('OWN_DIMENSIONS','0'),
('OWN_STRIDES','0')])
#-------------------------------------------------------------------------
# Configure the Agg backend to use on each platform
#-------------------------------------------------------------------------
if sys.platform=='win32':
plat = 'win32'
elif sys.platform == 'darwin':
plat = 'gl'
else:
#plat = 'gtk1' # use with gtk1, it's fast
plat = 'x11' # use with gtk2, it's slow but reliable
#plat = 'gdkpixbuf2'
#-------------------------------------------------------------------------
# Add the freetype library (agg 2.4 links against this)
#-------------------------------------------------------------------------
prefix = config.paths('freetype2/src')[0]
freetype_lib = 'freetype2_src'
def get_ft2_sources(name_info, build_dir):
(lib_name, build_info) = name_info
sources = [prefix + "/" + s for s in freetype2_sources]
if sys.platform=='darwin':
return sources[:]
return sources[:-1]
ft2_incl_dirs = ['freetype2/src/' + s for s in freetype2_dirs] \
+ ['freetype2/include', 'freetype2/src']
ft2_incl_dirs = config.paths(*ft2_incl_dirs)
if sys.platform == 'darwin' and '64bit' not in platform.architecture():
ft2_incl_dirs.append("/Developer/Headers/FlatCarbon")
config.add_library(freetype_lib,
sources = [get_ft2_sources],
include_dirs = ft2_incl_dirs,
# This macro was introduced in Freetype 2.2; if it is
# not defined, then the ftheader.h file (one of the
# primary headers) won't pull in any additional internal
# Freetype headers, and the library will mysteriously
# fail to build.
macros = [("FT2_BUILD_LIBRARY", None)],
depends = ['freetype2'],
)
#-------------------------------------------------------------------------
# Add the Agg sources
#-------------------------------------------------------------------------
agg_include_dirs = [agg_dir+'/include',agg_dir+'/font_freetype'] + \
ft2_incl_dirs
agg_sources = [agg_dir+'/src/*.cpp',
agg_dir+'/font_freetype/*.cpp']
config.add_library(agg_lib,
agg_sources,
include_dirs = agg_include_dirs,
depends = [agg_dir])
#-------------------------------------------------------------------------
# Add the Kiva sources
#-------------------------------------------------------------------------
if sys.platform == 'darwin':
define_macros = [('__DARWIN__', None)]
macros = [('__DARWIN__', None)]
extra_link_args = ['-framework', 'Carbon']
else:
define_macros = []
macros = []
extra_link_args = []
kiva_include_dirs = ['src'] + agg_include_dirs
config.add_library('kiva_src',
['src/kiva_*.cpp', 'src/gl_graphics_context.cpp'],
include_dirs = kiva_include_dirs,
# Use "macros" instead of "define_macros" because the
# latter is only used for extensions, and not clibs
macros = macros,
)
# MSVC6.0: uncomment to handle template parameters:
#extra_compile_args = ['/Zm1000']
extra_compile_args = []
# XXX: test whether numpy has weakref support
#-------------------------------------------------------------------------
# Build the extension itself
#-------------------------------------------------------------------------
# Check for g++ < 4.0 on 64-bit Linux
use_32bit_workaround = False
if sys.platform == 'linux2' and '64bit' in platform.architecture():
f = os.popen("g++ --version")
line0 = f.readline()
f.close()
m = re.match(r'.+?\s([3-5])\.\d+', line0)
if m is not None and int(m.group(1)) < 4:
use_32bit_workaround = True
# Enable workaround of agg bug on 64-bit machines with g++ < 4.0
if use_32bit_workaround:
define_macros.append(("ALWAYS_32BIT_WORKAROUND", 1))
# Options to make OS X link OpenGL
if '64bit' not in platform.architecture():
darwin_frameworks = ['Carbon', 'ApplicationServices', 'OpenGL']
else:
darwin_frameworks = ['ApplicationServices', 'OpenGL']
darwin_opengl_opts = dict(
include_dirs = [
'/System/Library/Frameworks/%s.framework/Versions/A/Headers' % x
for x in darwin_frameworks],
define_macros = [('__DARWIN__',None)],
extra_link_args = ['-framework %s' % x for x in darwin_frameworks]
)
build_info = {}
kiva_lib = 'kiva_src'
build_libraries = [kiva_lib, agg_lib, freetype_lib]
if sys.platform == "win32":
build_libraries += ["opengl32", "glu32"]
elif sys.platform == "darwin":
dict_append(build_info, **darwin_opengl_opts)
else:
# This should work for most linuxes (linuces?)
build_libraries += ["GL", "GLU"]
dict_append(build_info,
sources = ['agg.i'],
include_dirs = kiva_include_dirs,
libraries = build_libraries,
depends = ['src/*.[ih]'],
extra_compile_args = extra_compile_args,
extra_link_args = extra_link_args,
define_macros=define_macros,
)
dict_append(build_info, **numerix_info)
config.add_extension('_agg', **build_info)
sources = [os.path.join('src',plat,'plat_support.i'),
os.path.join('src',plat,'agg_bmp.cpp'),
]
if plat != 'gl':
sources.append(os.path.join('src',plat,'agg_platform_specific.cpp'))
plat_info = {}
dict_append(plat_info, libraries = [agg_lib],
include_dirs = kiva_include_dirs,
extra_compile_args = extra_compile_args,
depends = ['src'])
dict_append(plat_info, **numerix_info)
if plat=='win32':
dict_append(plat_info, libraries = ['gdi32','user32'])
elif plat in ['x11','gtk1']:
# Make sure we raise an error if the information is not found.
# Frequently, the 64-bit libraries are not in a known location and need
# manual configuration. From experience, this is usually not detected by
# the builder if we do not raise an exception.
x11_info = get_info('x11', notfound_action=2)
dict_append(plat_info, **x11_info)
elif plat=='gdkpixbuf2':
#gdk_pixbuf_xlib_2 = get_info('gdk_pixbuf_xlib_2',notfound_action=1)
#dict_append(plat_info,**gdk_pixbuf_xlib_2)
gtk_info = get_info('gtk+-2.0')
dict_append(plat_info, **gtk_info)
#x11_info = get_info('x11',notfound_action=1)
#dict_append(plat_info,**x11_info)
elif plat == 'gl':
if sys.platform == 'darwin':
dict_append(plat_info, **darwin_opengl_opts)
else:
msg = "OpenGL build support only on MacOSX right now."
raise NotImplementedError(msg)
config.add_extension('_plat_support',
sources,
**plat_info
)
config.add_data_dir('tests')
config.add_data_files('*.txt', '*.bat')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration, dot_join
from numpy.distutils.system_info import get_info
config = Configuration('core', parent_package, top_path)
local_dir = config.local_path
codegen_dir = join(local_dir, 'code_generators')
if is_released(config):
warnings.simplefilter('error', MismatchCAPIWarning)
# Check whether we have a mismatch between the set C API VERSION and the
# actual C API VERSION
check_api_version(C_API_VERSION, codegen_dir)
generate_umath_py = join(codegen_dir, 'generate_umath.py')
n = dot_join(config.name, 'generate_umath')
generate_umath = npy_load_module('_'.join(n.split('.')),
generate_umath_py, ('.py', 'U', 1))
header_dir = 'include/numpy' # this is relative to config.path_in_package
cocache = CallOnceOnly()
def generate_config_h(ext, build_dir):
target = join(build_dir, header_dir, 'config.h')
d = os.path.dirname(target)
if not os.path.exists(d):
os.makedirs(d)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
# Check sizeof
moredefs, ignored = cocache.check_types(config_cmd, ext, build_dir)
# Check math library and C99 math funcs availability
mathlibs = check_mathlib(config_cmd)
moredefs.append(('MATHLIB', ','.join(mathlibs)))
check_math_capabilities(config_cmd, moredefs, mathlibs)
moredefs.extend(cocache.check_ieee_macros(config_cmd)[0])
moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[0])
# Signal check
if is_npy_no_signal():
moredefs.append('__NPY_PRIVATE_NO_SIGNAL')
# Windows checks
if sys.platform == 'win32' or os.name == 'nt':
win32_checks(moredefs)
# C99 restrict keyword
moredefs.append(('NPY_RESTRICT', config_cmd.check_restrict()))
# Inline check
inline = config_cmd.check_inline()
# Use relaxed stride checking
if NPY_RELAXED_STRIDES_CHECKING:
moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
# Use bogus stride debug aid when relaxed strides are enabled
if NPY_RELAXED_STRIDES_DEBUG:
moredefs.append(('NPY_RELAXED_STRIDES_DEBUG', 1))
# Get long double representation
if sys.platform != 'darwin':
rep = check_long_double_representation(config_cmd)
if rep in ['INTEL_EXTENDED_12_BYTES_LE',
'INTEL_EXTENDED_16_BYTES_LE',
'MOTOROLA_EXTENDED_12_BYTES_BE',
'IEEE_QUAD_LE', 'IEEE_QUAD_BE',
'IEEE_DOUBLE_LE', 'IEEE_DOUBLE_BE',
'DOUBLE_DOUBLE_BE', 'DOUBLE_DOUBLE_LE']:
moredefs.append(('HAVE_LDOUBLE_%s' % rep, 1))
else:
raise ValueError("Unrecognized long double format: %s" % rep)
# Py3K check
if sys.version_info[0] == 3:
moredefs.append(('NPY_PY3K', 1))
# Generate the config.h file from moredefs
target_f = open(target, 'w')
for d in moredefs:
if isinstance(d, str):
target_f.write('#define %s\n' % (d))
else:
target_f.write('#define %s %s\n' % (d[0], d[1]))
# define inline to our keyword, or nothing
target_f.write('#ifndef __cplusplus\n')
if inline == 'inline':
target_f.write('/* #undef inline */\n')
else:
target_f.write('#define inline %s\n' % inline)
target_f.write('#endif\n')
# add the guard to make sure config.h is never included directly,
# but always through npy_config.h
target_f.write("""
#ifndef _NPY_NPY_CONFIG_H_
#error config.h should never be included directly, include npy_config.h instead
#endif
""")
target_f.close()
print('File:', target)
target_f = open(target)
print(target_f.read())
target_f.close()
print('EOF')
else:
mathlibs = []
target_f = open(target)
for line in target_f:
s = '#define MATHLIB'
if line.startswith(s):
value = line[len(s):].strip()
if value:
mathlibs.extend(value.split(','))
target_f.close()
# Ugly: this can be called within a library and not an extension,
# in which case there is no libraries attributes (and none is
# needed).
if hasattr(ext, 'libraries'):
ext.libraries.extend(mathlibs)
incl_dir = os.path.dirname(target)
if incl_dir not in config.numpy_include_dirs:
config.numpy_include_dirs.append(incl_dir)
return target
def generate_numpyconfig_h(ext, build_dir):
"""Depends on config.h: generate_config_h has to be called before !"""
# put private include directory in build_dir on search path
# allows using code generation in headers headers
config.add_include_dirs(join(build_dir, "src", "private"))
config.add_include_dirs(join(build_dir, "src", "npymath"))
target = join(build_dir, header_dir, '_numpyconfig.h')
d = os.path.dirname(target)
if not os.path.exists(d):
os.makedirs(d)
if newer(__file__, target):
config_cmd = config.get_config_cmd()
log.info('Generating %s', target)
# Check sizeof
ignored, moredefs = cocache.check_types(config_cmd, ext, build_dir)
if is_npy_no_signal():
moredefs.append(('NPY_NO_SIGNAL', 1))
if is_npy_no_smp():
moredefs.append(('NPY_NO_SMP', 1))
else:
moredefs.append(('NPY_NO_SMP', 0))
mathlibs = check_mathlib(config_cmd)
moredefs.extend(cocache.check_ieee_macros(config_cmd)[1])
moredefs.extend(cocache.check_complex(config_cmd, mathlibs)[1])
if NPY_RELAXED_STRIDES_CHECKING:
moredefs.append(('NPY_RELAXED_STRIDES_CHECKING', 1))
if NPY_RELAXED_STRIDES_DEBUG:
moredefs.append(('NPY_RELAXED_STRIDES_DEBUG', 1))
# Check wether we can use inttypes (C99) formats
if config_cmd.check_decl('PRIdPTR', headers=['inttypes.h']):
moredefs.append(('NPY_USE_C99_FORMATS', 1))
# visibility check
hidden_visibility = visibility_define(config_cmd)
moredefs.append(('NPY_VISIBILITY_HIDDEN', hidden_visibility))
# Add the C API/ABI versions
moredefs.append(('NPY_ABI_VERSION', '0x%.8X' % C_ABI_VERSION))
moredefs.append(('NPY_API_VERSION', '0x%.8X' % C_API_VERSION))
# Add moredefs to header
target_f = open(target, 'w')
for d in moredefs:
if isinstance(d, str):
target_f.write('#define %s\n' % (d))
else:
target_f.write('#define %s %s\n' % (d[0], d[1]))
# Define __STDC_FORMAT_MACROS
target_f.write("""
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS 1
#endif
""")
target_f.close()
# Dump the numpyconfig.h header to stdout
print('File: %s' % target)
target_f = open(target)
print(target_f.read())
target_f.close()
print('EOF')
config.add_data_files((header_dir, target))
return target
def generate_api_func(module_name):
def generate_api(ext, build_dir):
script = join(codegen_dir, module_name + '.py')
sys.path.insert(0, codegen_dir)
try:
m = __import__(module_name)
log.info('executing %s', script)
h_file, c_file, doc_file = m.generate_api(os.path.join(build_dir, header_dir))
finally:
del sys.path[0]
config.add_data_files((header_dir, h_file),
(header_dir, doc_file))
return (h_file,)
return generate_api
generate_numpy_api = generate_api_func('generate_numpy_api')
generate_ufunc_api = generate_api_func('generate_ufunc_api')
config.add_include_dirs(join(local_dir, "src", "private"))
config.add_include_dirs(join(local_dir, "src"))
config.add_include_dirs(join(local_dir))
config.add_data_files('include/numpy/*.h')
config.add_include_dirs(join('src', 'npymath'))
config.add_include_dirs(join('src', 'multiarray'))
config.add_include_dirs(join('src', 'umath'))
config.add_include_dirs(join('src', 'npysort'))
config.add_include_dirs(join('src', 'mkl_defs'))
config.add_define_macros([("NPY_INTERNAL_BUILD", "1")]) # this macro indicates that Numpy build is in process
config.add_define_macros([("HAVE_NPY_CONFIG_H", "1")])
if sys.platform[:3] == "aix":
config.add_define_macros([("_LARGE_FILES", None)])
else:
config.add_define_macros([("_FILE_OFFSET_BITS", "64")])
config.add_define_macros([('_LARGEFILE_SOURCE', '1')])
config.add_define_macros([('_LARGEFILE64_SOURCE', '1')])
config.numpy_include_dirs.extend(config.paths('include'))
deps = [join('src', 'npymath', '_signbit.c'),
join('include', 'numpy', '*object.h'),
join(codegen_dir, 'genapi.py'),
]
#######################################################################
# dummy module #
#######################################################################
# npymath needs the config.h and numpyconfig.h files to be generated, but
# build_clib cannot handle generate_config_h and generate_numpyconfig_h
# (don't ask). Because clib are generated before extensions, we have to
# explicitly add an extension which has generate_config_h and
# generate_numpyconfig_h as sources *before* adding npymath.
config.add_extension('_dummy',
sources=[join('src', 'dummymodule.c'),
generate_config_h,
generate_numpyconfig_h,
generate_numpy_api]
)
#######################################################################
# npymath library #
#######################################################################
subst_dict = dict([("sep", os.path.sep), ("pkgname", "numpy.core")])
def get_mathlib_info(*args):
# Another ugly hack: the mathlib info is known once build_src is run,
# but we cannot use add_installed_pkg_config here either, so we only
# update the substition dictionary during npymath build
config_cmd = config.get_config_cmd()
# Check that the toolchain works, to fail early if it doesn't
# (avoid late errors with MATHLIB which are confusing if the
# compiler does not work).
st = config_cmd.try_link('int main(void) { return 0;}')
if not st:
raise RuntimeError("Broken toolchain: cannot link a simple C program")
mlibs = check_mathlib(config_cmd)
posix_mlib = ' '.join(['-l%s' % l for l in mlibs])
msvc_mlib = ' '.join(['%s.lib' % l for l in mlibs])
subst_dict["posix_mathlib"] = posix_mlib
subst_dict["msvc_mathlib"] = msvc_mlib
npymath_sources = [join('src', 'npymath', 'npy_math_internal.h.src'),
join('src', 'npymath', 'npy_math.c'),
join('src', 'npymath', 'ieee754.c.src'),
join('src', 'npymath', 'npy_math_complex.c.src'),
join('src', 'npymath', 'halffloat.c')
]
# Must be true for CRT compilers but not MinGW/cygwin. See gh-9977.
is_msvc = platform.system() == 'Windows'
config.add_installed_library('npymath',
sources=npymath_sources + [get_mathlib_info],
install_dir='lib',
build_info={
'include_dirs' : [], # empty list required for creating npy_math_internal.h
'extra_compiler_args' : (['/GL-'] if is_msvc else []),
})
config.add_npy_pkg_config("npymath.ini.in", "lib/npy-pkg-config",
subst_dict)
config.add_npy_pkg_config("mlib.ini.in", "lib/npy-pkg-config",
subst_dict)
#######################################################################
# aligned_alloc library #
#######################################################################
# This library is created for the build but it is not installed
aligned_alloc_sources = [join('src', 'mkl_defs', 'aligned_alloc.h'),
join('src', 'mkl_defs', 'aligned_alloc.c')]
config.add_library('aligned_alloc',
sources=aligned_alloc_sources,
include_dirs=[])
#######################################################################
# npysort library #
#######################################################################
# This library is created for the build but it is not installed
npysort_sources = [join('src', 'npysort', 'quicksort.c.src'),
join('src', 'npysort', 'mergesort.c.src'),
join('src', 'npysort', 'heapsort.c.src'),
join('src', 'private', 'npy_partition.h.src'),
join('src', 'npysort', 'selection.c.src'),
join('src', 'private', 'npy_binsearch.h.src'),
join('src', 'npysort', 'binsearch.c.src'),
]
config.add_library('npysort',
sources=npysort_sources,
include_dirs=[])
#######################################################################
# mkl_cp library #
#######################################################################
# This library is created for the build but it is not installed
mkl_cp_sources = [join('src', 'mkl_defs', 'mkl_cpy.h'),
join('src', 'mkl_defs', 'mkl_cpy.c')]
config.add_library('mkl_cp',
sources=mkl_cp_sources,
include_dirs=[])
#######################################################################
# multiarray module #
#######################################################################
multiarray_deps = [
join('src', 'multiarray', 'arrayobject.h'),
join('src', 'multiarray', 'arraytypes.h'),
join('src', 'multiarray', 'array_assign.h'),
join('src', 'multiarray', 'buffer.h'),
join('src', 'multiarray', 'calculation.h'),
join('src', 'multiarray', 'cblasfuncs.h'),
join('src', 'multiarray', 'common.h'),
join('src', 'multiarray', 'convert_datatype.h'),
join('src', 'multiarray', 'convert.h'),
join('src', 'multiarray', 'conversion_utils.h'),
join('src', 'multiarray', 'ctors.h'),
join('src', 'multiarray', 'descriptor.h'),
join('src', 'multiarray', 'dragon4.h'),
join('src', 'multiarray', 'getset.h'),
join('src', 'multiarray', 'hashdescr.h'),
join('src', 'multiarray', 'iterators.h'),
join('src', 'multiarray', 'mapping.h'),
join('src', 'multiarray', 'methods.h'),
join('src', 'multiarray', 'multiarraymodule.h'),
join('src', 'multiarray', 'nditer_impl.h'),
join('src', 'multiarray', 'number.h'),
join('src', 'multiarray', 'numpyos.h'),
join('src', 'multiarray', 'refcount.h'),
join('src', 'multiarray', 'scalartypes.h'),
join('src', 'multiarray', 'sequence.h'),
join('src', 'multiarray', 'shape.h'),
join('src', 'multiarray', 'strfuncs.h'),
join('src', 'multiarray', 'ucsnarrow.h'),
join('src', 'multiarray', 'usertypes.h'),
join('src', 'multiarray', 'vdot.h'),
join('src', 'private', 'npy_config.h'),
join('src', 'private', 'templ_common.h.src'),
join('src', 'private', 'lowlevel_strided_loops.h'),
join('src', 'private', 'mem_overlap.h'),
join('src', 'private', 'npy_longdouble.h'),
join('src', 'private', 'ufunc_override.h'),
join('src', 'private', 'binop_override.h'),
join('src', 'private', 'npy_extint128.h'),
join('include', 'numpy', 'arrayobject.h'),
join('include', 'numpy', '_neighborhood_iterator_imp.h'),
join('include', 'numpy', 'npy_endian.h'),
join('include', 'numpy', 'arrayscalars.h'),
join('include', 'numpy', 'noprefix.h'),
join('include', 'numpy', 'npy_interrupt.h'),
join('include', 'numpy', 'npy_3kcompat.h'),
join('include', 'numpy', 'halffloat.h'),
join('include', 'numpy', 'npy_common.h'),
join('include', 'numpy', 'npy_os.h'),
join('include', 'numpy', 'utils.h'),
join('include', 'numpy', 'ndarrayobject.h'),
join('include', 'numpy', 'npy_cpu.h'),
join('include', 'numpy', 'numpyconfig.h'),
join('include', 'numpy', 'ndarraytypes.h'),
join('include', 'numpy', 'npy_1_7_deprecated_api.h'),
# add library sources as distuils does not consider libraries
# dependencies
] + npysort_sources
multiarray_src = [
join('src', 'multiarray', 'alloc.c'),
join('src', 'multiarray', 'arrayobject.c'),
join('src', 'multiarray', 'arraytypes.c.src'),
join('src', 'multiarray', 'array_assign.c'),
join('src', 'multiarray', 'array_assign_scalar.c'),
join('src', 'multiarray', 'array_assign_array.c'),
join('src', 'multiarray', 'buffer.c'),
join('src', 'multiarray', 'calculation.c'),
join('src', 'multiarray', 'compiled_base.c'),
join('src', 'multiarray', 'common.c'),
join('src', 'multiarray', 'convert.c'),
join('src', 'multiarray', 'convert_datatype.c'),
join('src', 'multiarray', 'conversion_utils.c'),
join('src', 'multiarray', 'ctors.c'),
join('src', 'multiarray', 'datetime.c'),
join('src', 'multiarray', 'datetime_strings.c'),
join('src', 'multiarray', 'datetime_busday.c'),
join('src', 'multiarray', 'datetime_busdaycal.c'),
join('src', 'multiarray', 'descriptor.c'),
join('src', 'multiarray', 'dragon4.c'),
join('src', 'multiarray', 'dtype_transfer.c'),
join('src', 'multiarray', 'einsum.c.src'),
join('src', 'multiarray', 'flagsobject.c'),
join('src', 'multiarray', 'getset.c'),
join('src', 'multiarray', 'hashdescr.c'),
join('src', 'multiarray', 'item_selection.c'),
join('src', 'multiarray', 'iterators.c'),
join('src', 'multiarray', 'lowlevel_strided_loops.c.src'),
join('src', 'multiarray', 'mapping.c'),
join('src', 'multiarray', 'methods.c'),
join('src', 'multiarray', 'multiarraymodule.c'),
join('src', 'multiarray', 'nditer_templ.c.src'),
join('src', 'multiarray', 'nditer_api.c'),
join('src', 'multiarray', 'nditer_constr.c'),
join('src', 'multiarray', 'nditer_pywrap.c'),
join('src', 'multiarray', 'number.c'),
join('src', 'multiarray', 'numpyos.c'),
join('src', 'multiarray', 'refcount.c'),
join('src', 'multiarray', 'sequence.c'),
join('src', 'multiarray', 'shape.c'),
join('src', 'multiarray', 'scalarapi.c'),
join('src', 'multiarray', 'scalartypes.c.src'),
join('src', 'multiarray', 'strfuncs.c'),
join('src', 'multiarray', 'temp_elide.c'),
join('src', 'multiarray', 'usertypes.c'),
join('src', 'multiarray', 'ucsnarrow.c'),
join('src', 'multiarray', 'vdot.c'),
join('src', 'private', 'templ_common.h.src'),
join('src', 'private', 'mem_overlap.c'),
join('src', 'private', 'npy_longdouble.c'),
join('src', 'private', 'ufunc_override.c'),
]
blas_info = get_info('blas_opt', 0)
if blas_info and ('HAVE_CBLAS', None) in blas_info.get('define_macros', []):
extra_info = blas_info
# These files are also in MANIFEST.in so that they are always in
# the source distribution independently of HAVE_CBLAS.
multiarray_src.extend([join('src', 'multiarray', 'cblasfuncs.c'),
join('src', 'multiarray', 'python_xerbla.c'),
])
if uses_accelerate_framework(blas_info):
multiarray_src.extend(get_sgemv_fix())
else:
extra_info = {}
config.add_extension('multiarray',
sources=multiarray_src +
[generate_config_h,
generate_numpyconfig_h,
generate_numpy_api,
join(codegen_dir, 'generate_numpy_api.py'),
join('*.py')],
extra_compile_args=[],
depends=deps + multiarray_deps,
libraries=['npymath', 'npysort', 'aligned_alloc', 'mkl_cp'],
extra_info=get_info('mkl'))
#######################################################################
# umath module #
#######################################################################
def generate_umath_c(ext, build_dir):
target = join(build_dir, header_dir, '__umath_generated.c')
dir = os.path.dirname(target)
if not os.path.exists(dir):
os.makedirs(dir)
script = generate_umath_py
if newer(script, target):
f = open(target, 'w')
f.write(generate_umath.make_code(generate_umath.defdict,
generate_umath.__file__))
f.close()
return []
loops_src = [join('src', 'umath', 'loops.c.src'),
join('src', 'umath', 'loops.h.src'),]
umath_src = [
join('src', 'umath', 'umathmodule.c'),
join('src', 'umath', 'reduction.c'),
join('src', 'umath', 'funcs.inc.src'),
join('src', 'umath', 'simd.inc.src'),
join('src', 'umath', 'ufunc_object.c'),
join('src', 'umath', 'extobj.c'),
join('src', 'umath', 'scalarmath.c.src'),
join('src', 'umath', 'ufunc_type_resolution.c'),
join('src', 'umath', 'override.c'),
join('src', 'private', 'mem_overlap.c'),
join('src', 'private', 'npy_longdouble.c'),
join('src', 'private', 'ufunc_override.c')]
umath_deps = [
generate_umath_py,
join('include', 'numpy', 'npy_math.h'),
join('include', 'numpy', 'halffloat.h'),
join('src', 'multiarray', 'common.h'),
join('src', 'private', 'templ_common.h.src'),
join('src', 'umath', 'simd.inc.src'),
join('src', 'umath', 'override.h'),
join(codegen_dir, 'generate_ufunc_api.py'),
join('src', 'private', 'lowlevel_strided_loops.h'),
join('src', 'private', 'mem_overlap.h'),
join('src', 'private', 'npy_longdouble.h'),
join('src', 'private', 'ufunc_override.h'),
join('src', 'private', 'binop_override.h')] + npymath_sources
npymathc_path = join('build', 'src.%s-%s.%s' % (sysconfig.get_platform(), sys.version_info[0], sys.version_info[1]), 'numpy', 'core', 'src', 'npymath')
# if platform.system() == "Windows":
# eca = ['/fp:fast=2', '/Qimf-precision=high', '/Qprec-sqrt', '/Qstd=c99']
# if sys.version_info < (3, 0):
# eca.append('/Qprec-div')
# else:
# eca = ['-fp-model fast=2', '-fimf-precision=high', '-prec-sqrt']
eca=[]
config.add_library('loops',
sources=loops_src,
include_dirs=[npymathc_path],
extra_compiler_args=eca,
depends=deps + umath_deps,
)
mkl_info = get_info('mkl')
config.add_extension('umath',
sources=umath_src +
[generate_config_h,
generate_numpyconfig_h,
generate_umath_c,
generate_ufunc_api],
include_dirs=[npymathc_path],
depends=deps + umath_deps + loops_src,
libraries=['loops', 'npymath', 'aligned_alloc', 'mkl_cp'],
extra_info=mkl_info
)
#######################################################################
# umath_tests module #
#######################################################################
config.add_extension('umath_tests',
sources=[join('src', 'umath', 'umath_tests.c.src')])
#######################################################################
# custom rational dtype module #
#######################################################################
config.add_extension('test_rational',
sources=[join('src', 'umath', 'test_rational.c.src')],
libraries=['mkl_cp'],
extra_info=mkl_info
)
#######################################################################
# struct_ufunc_test module #
#######################################################################
config.add_extension('struct_ufunc_test',
sources=[join('src', 'umath', 'struct_ufunc_test.c.src')])
#######################################################################
# multiarray_tests module #
#######################################################################
config.add_extension('multiarray_tests',
sources=[join('src', 'multiarray', 'multiarray_tests.c.src'),
join('src', 'private', 'mem_overlap.c')],
depends=[join('src', 'private', 'mem_overlap.h'),
join('src', 'private', 'npy_extint128.h')],
libraries=['npymath'])
#######################################################################
# operand_flag_tests module #
#######################################################################
config.add_extension('operand_flag_tests',
sources=[join('src', 'umath', 'operand_flag_tests.c.src')])
config.add_data_dir('tests')
config.add_data_dir('tests/data')
config.make_svn_version_py()
return config
