def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
# We need this because libcstat.a is linked to lapack, which can
# be a fortran library, and the linker needs this information.
from numpy.distutils.system_info import get_info
# First, try 'lapack_info', as that seems to provide more details on Linux
# (both 32 and 64 bits):
lapack_info = get_info('lapack_opt', 0)
if 'libraries' not in lapack_info:
# But on OSX that may not give us what we need, so try with 'lapack'
# instead. NOTE: scipy.linalg uses lapack_opt, not 'lapack'...
lapack_info = get_info('lapack',0)
config = Configuration('group', parent_package, top_path)
config.add_subpackage('tests')
config.add_extension(
'onesample',
sources=['onesample.pyx'],
libraries=['cstat'],
extra_info=lapack_info,
)
config.add_extension(
'twosample',
sources=['twosample.pyx'],
libraries=['cstat'],
extra_info=lapack_info,
)
config.add_extension(
'glm_twolevel',
sources=['glm_twolevel.pyx'],
libraries=['cstat'],
extra_info=lapack_info,
)
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, dict_append
config = Configuration('umfpack', parent_package, top_path)
config.add_data_dir('tests')
umf_info = get_info('umfpack', notfound_action=1)
## The following addition is needed when linking against a umfpack built
## from the latest SparseSuite. Not (strictly) needed when linking against
## the version in the ubuntu repositories.
if not sys.platform == 'darwin':
umf_info['libraries'].insert(0, 'rt')
umfpack_i_file = config.paths('umfpack.i')[0]
def umfpack_i(ext, build_dir):
if umf_info:
return umfpack_i_file
blas_info = get_info('blas_opt')
build_info = {}
dict_append(build_info, **umf_info)
dict_append(build_info, **blas_info)
config.add_extension('__umfpack',
sources=[umfpack_i],
depends=['umfpack.i'],
**build_info)
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')
# We need this because libcstat.a is linked to lapack, which can
# be a fortran library, and the linker needs this information.
from numpy.distutils.system_info import get_info
lapack_info = get_info('lapack_opt',0)
if 'libraries' not in lapack_info:
# But on OSX that may not give us what we need, so try with 'lapack'
# instead. NOTE: scipy.linalg uses lapack_opt, not 'lapack'...
lapack_info = get_info('lapack',0)
config.add_extension(
'_graph',
sources=['graph.c'],
libraries=['cstat'],
extra_info=lapack_info,
)
config.add_extension(
'_field',
sources=['field.c'],
libraries=['cstat'],
extra_info=lapack_info,
)
return config
def configuration(parent_package='',top_path=None):
import numpy
import os
#import sys
import ConfigParser
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, NotFoundError
# Read relevant PySparse-specific configuration options.
#pysparse_config = ConfigParser.SafeConfigParser()
#pysparse_config.read(os.path.join(top_path, 'site.cfg'))
#hsl_dir = pysparse_config.get('HSL', 'hsl_dir')
config = Configuration('sparse', parent_package, top_path)
# Get BLAS info from site.cfg
blas_info = get_info('blas_opt',0)
if not blas_info:
blas_info = get_info('blas',0)
if not blas_info:
print 'No blas info found'
print 'Using BLAS info:' ; print blas_info
spmatrix_src = ['spmatrixmodule.c']
config.add_extension(
name='spmatrix',
define_macros=[('LENFUNC_OK', 1)],
sources=[os.path.join('src',name) for name in spmatrix_src],
libraries=[],
include_dirs=['src'],
extra_info=blas_info,
)
config.make_config_py()
return config
def configuration(parent_package='',top_path=None):
import numpy
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, dict_append
config = Configuration('umfpack', parent_package, top_path)
config.add_data_dir('tests')
umf_info = get_info('umfpack', notfound_action=1)
umfpack_i_file = config.paths('umfpack.i')[0]
def umfpack_i(ext, build_dir):
if umf_info:
return umfpack_i_file
blas_info = get_info('blas_opt')
build_info = {}
dict_append(build_info, **umf_info)
dict_append(build_info, **blas_info)
#config.add_extension('__umfpack',
# sources=[umfpack_i],
# depends=['umfpack.i'],
# **build_info)
return config
def run_install():
if env_lib_dirs or env_libs:
print("using environment variables for blas/lapack libraries")
env_vars = {}
if env_lib_dirs:
env_vars['library_dirs'] = env_lib_dirs.split(':')
if env_libs:
env_vars['libraries'] = env_libs.split(':')
install_scs(blas_info=env_vars, lapack_info={})
return
# environment variables not set, using defaults instead
try:
print("using blas_opt / lapack_opt")
install_scs(blas_info=get_info('blas_opt'), lapack_info=get_info('lapack_opt'))
return
except:
pass # fall back to blas / lapack (not opt)
print("blas_opt / lapack_opt install failed, trying blas / lapack")
try:
install_scs(blas_info=get_info('blas'), lapack_info=get_info('lapack'))
except:
install_scs(blas_info={}, lapack_info={})
print("###############################################################################################")
print("# failed to find blas/lapack libs, SCS cannot solve SDPs but can solve LPs, SOCPs, ECPs, PCPs #")
print("# install blas/lapack and run this install script again to allow SCS to solve SDPs #")
print("# #")
print("# scs will use environment variables BLAS_LAPACK_LIB_PATHS and BLAS_LAPACK_LIBS if set #")
print("# use this to link against blas/lapack libs that scs can't find on it's own, usage ex: #")
print("# >> export BLAS_LAPACK_LIB_PATHS=/usr/lib/:/other/dir #")
print("# >> export BLAS_LAPACK_LIBS=blas:lapack #")
print("# >> python setup.py install #")
print("###############################################################################################")
def get_blas_lapack_info():
""" Try three methods for getting blas/lapack info.
If successful, set LAPACK_LIB_FOUND and return dictionary with the arguments
If not successful, print error message and return empty dictionary
"""
info = {}
if not info:
print("Trying 'lapack_opt'")
info = get_info('lapack_opt')
if not info:
print("lapack_opt failed. Trying 'lapack'")
info = get_info('lapack')
if info:
info['define_macros'] = info.get('define_macros', []) + [('LAPACK_LIB_FOUND', None)]
print('the resulting info is: ', info)
else:
print("##########################################################################################")
print("# failed to find lapack libs, SCS cannot solve SDPs but can solve LPs, SOCPs, ECPs, PCPs #")
print("# install lapack and run this install script again to allow SCS to solve SDPs #")
print("##########################################################################################")
return info
def matrix_initialize():
global initializedMatrix
global useBLAS
global useNumpy # module based variable
global dgemm
if initializedMatrix:
sys.stderr.write("INFO: matrix_inialize called multiple times\n")
return
if useBLAS and useNumpy is None:
print get_info('blas_opt')
try:
from scipy.linalg.blas import dgemm
sys.stderr.write("INFO: using linalg.fblas\n")
useNumpy = False
hasBLAS = True
except AttributeError:
sys.stderr.write("WARNING: linalg.fblas not found, using numpy.dot instead!\n")
useNumpy = True
else:
sys.stderr.write("INFO: using numpy.dot\n")
useNumpy=True
if cuda.useCUDA:
sys.stderr.write("INFO: with CUDA support\n")
initializedMatrix = True
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info
from arachnid.distutils.compiler import compiler_options #detect_openmp
import os
compiler_args, compiler_libraries, compiler_defs, ccompiler_args, ccompiler_lib, ccompiler_defs = compiler_options()[:6]
ccompiler_lib;
try:
fftw_opt = get_info('mkl',notfound_action=2)
except:
try:
fftw_opt = get_info('fftw',notfound_action=2)
#fftw_opt['libraries']=['fftw3f']
fftw_opt['libraries'].extend(['fftw3f'])
fftw_opt['library_dirs'].extend(['/usr/lib'])
except: fftw_opt=dict(libraries=['fftw3f'])
if 'library_dirs' not in fftw_opt: fftw_opt['library_dirs']=[]
if 'include_dirs' not in fftw_opt: fftw_opt['include_dirs']=[]
config = Configuration('spi', parent_package, top_path)
#-ftrap=common
if 1 == 0:
f2py_options = ['--debug-capi']
else: f2py_options=[]
flink_args = compiler_args
#-ffixed-form define_macros=[('SP_LIBFFTW3', 1)]+compiler_defs,
library_options=dict(macros=[('SP_LIBFFTW3', 1)]+compiler_defs, extra_f77_compile_args=compiler_args, extra_f90_compile_args=compiler_args)#extra_f77_compiler_args=['-fdefault-real-8'],, ('SP_MP', 1)
#extra_f90_compiler_args=['-fdefault-real-8'])
config.add_library('spiutil', sources=['spiutil.F90', 'spider/tfd.F90', 'spider/fq_q.F90', 'spider/fq3_p.F90', 'spider/parabl.F90', 'spider/pksr3.F90', 'spider/fftw3.F90',
'spider/ccrs.F90', 'spider/apcc.F90', 'spider/quadri.F90', 'spider/rtsq.F90', 'spider/cald.F90', 'spider/bldr.F90',
'spider/fmrs.F90', 'spider/fmrs_2.F90', 'spider/besi1.F90', 'spider/wpro_n.F90', 'spider/prepcub.F90',
'spider/fint.F90', 'spider/fint3.F90', 'spider/betai.F90', 'spider/gammln.F90', 'spider/betacf.F90', 'spider/histe.F90',
'spider/interp_fbs3.F90', 'spider/interp_fbs.F90', 'spider/fbs2.F90', 'spider/fbs3.F90'],
depends=['spider/CMBLOCK.INC', 'spider/FFTW3.INC'], **library_options) #, 'fmrs_info.mod', 'type_kinds.mod'
fftlibs = fftw_opt['libraries']+compiler_libraries
del fftw_opt['libraries']
config.add_extension('_spider_reconstruct', sources=['backproject_nn4.f90', 'backproject_bp3f.f90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=flink_args, library_dirs=fftw_opt['library_dirs'])
config.add_extension('_spider_reproject', sources=['reproject.F90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=flink_args, library_dirs=fftw_opt['library_dirs'])
config.add_extension('_spider_interpolate', sources=['interpolate.F90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=flink_args, library_dirs=fftw_opt['library_dirs'])
config.add_extension('_spider_ctf', sources=['ctf.F90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=flink_args, library_dirs=fftw_opt['library_dirs'])
#config.add_extension('_spider_interpolate', sources=['interpolate.F90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=compiler_args, library_dirs=fftw_opt['library_dirs'])
#-fdefault-real-8
#rot_src = 'spider_rotate_dist_wrap.cpp' if os.path.exists(os.path.join(os.path.dirname(__file__), 'spider_rotate_dist_wrap.cpp')) else 'rotate.i'
#config.add_extension('_spider_rotate_dist', sources=[rot_src], define_macros=[('__STDC_FORMAT_MACROS', 1)]+ccompiler_defs, depends=['rotate.hpp'], swig_opts=['-c++'], libraries=['spiutil']+fftlibs, extra_compile_args=ccompiler_args, extra_link_args=compiler_args, library_dirs=fftw_opt['library_dirs'])
config.add_extension('_spider_rotate', sources=['rotate.F90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=flink_args, library_dirs=fftw_opt['library_dirs'])
#config.add_extension('_spider_align', sources=['align.F90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=flink_args, library_dirs=fftw_opt['library_dirs'])
config.add_extension('_spider_filter', sources=['filter.F90'], libraries=['spiutil']+fftlibs, f2py_options=f2py_options, define_macros=ccompiler_defs, extra_compile_args=ccompiler_args, extra_link_args=flink_args, library_dirs=fftw_opt['library_dirs'])
config.add_include_dirs(os.path.dirname(__file__))
config.add_include_dirs(os.path.join(os.path.dirname(__file__), 'spider'))
config.add_include_dirs(fftw_opt['include_dirs'])
return config
def configuration(parent_package='',top_path=None):
import numpy
import os
import ConfigParser
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, NotFoundError
# Read relevant NLPy-specific configuration options.
nlpy_config = ConfigParser.SafeConfigParser()
nlpy_config.read(os.path.join(top_path, 'site.cfg'))
hsl_dir = nlpy_config.get('HSL', 'hsl_dir')
galahad_dir = nlpy_config.get('GALAHAD', 'galahad_dir')
config = Configuration('krylov', parent_package, top_path)
# Get BLAS info from site.cfg
blas_info = get_info('blas_opt',0)
if not blas_info:
print 'No blas info found'
lapack_info = get_info('lapack_opt',0)
if not lapack_info:
print 'No lapack info found'
gdir = os.path.join(galahad_dir,'src')
libgltr_src = [os.path.join(hsl_dir,'hsl_zd11d.f90'),
os.path.join(gdir,'auxiliary','norms.f90'),
os.path.join(gdir,'rand','rand.f90'),
os.path.join(gdir,'sym','symbols.f90'),
os.path.join(gdir,'smt','smt.f90'),
os.path.join(gdir,'space','space.f90'),
os.path.join(gdir,'spec','specfile.f90'),
os.path.join(gdir,'sort','sort.f90'),
os.path.join(gdir,'roots','roots.f90'),
os.path.join(gdir,'gltr','gltr.f90'),
os.path.join('src','pygltr.f90')]
pygltr_src = ['_pygltr.c']
# Build PyGLTR
config.add_library(
name='nlpy_gltr',
sources=libgltr_src,
extra_info=[blas_info, lapack_info],
)
config.add_extension(
name='_pygltr',
sources=[os.path.join('src',name) for name in pygltr_src],
libraries=['nlpy_gltr'],
include_dirs=['src'],
extra_info=[blas_info, lapack_info],
)
config.make_config_py()
return config
def get_numpy_options():
# Third-party modules - we depend on numpy for everything
import numpy
try:
from numpy.distutils.system_info import get_info
except:
from numpy.__config__ import get_info
# Obtain the numpy include directory
numpy_include = numpy.get_include()
# Obtain BLAS/LAPACK linking options
lapack_info = get_info('lapack_opt')
blas_info = get_info('blas_opt')
using_atlas = False
using_f77blas = False
using_lapack = False
for l in lapack_info.get('libraries', []) + blas_info.get('libraries', []):
if "atlas" in l: using_atlas = True
if "f77blas" in l: using_f77blas = True
if "lapack" in l: using_lapack = True
if using_atlas and (not using_f77blas or not using_lapack):
lapack_info = get_info('atlas')
# ATLAS notices an incomplete LAPACK by not setting language to f77
complete_lapack = lapack_info.get('language', "") == "f77"
if complete_lapack:
blas_info = {}
else:
# If ATLAS has an incomplete LAPACK, use a regular one
blas_info = get_info('atlas_blas')
lapack_info = get_info('lapack')
blaslapack_libraries = lapack_info.get('libraries', []) + blas_info.get('libraries', [])
blaslapack_library_dirs = lapack_info.get('library_dirs', []) + blas_info.get('library_dirs', [])
blaslapack_extra_link_args = lapack_info.get('extra_link_args', []) + blas_info.get('extra_link_args', [])
if not blaslapack_libraries and not blaslapack_extra_link_args:
blaslapack_libraries = ['lapack', 'blas']
r = dict(
include_dirs = [numpy_include, "primme/include", "primme/src/include"],
library_dirs = blaslapack_library_dirs,
libraries = blaslapack_libraries,
extra_link_args = blaslapack_extra_link_args
)
# Link dynamically on Windows and statically otherwise
if sys.platform == 'win32':
r['libraries'] = ['primme'] + r['libraries']
else:
r['extra_objects'] = ['../lib/libprimme.a']
return r
def configuration(parent_package='',top_path=None):
import numpy
import os
import ConfigParser
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, NotFoundError
# Read relevant PySparse-specific configuration options.
pysparse_config = ConfigParser.SafeConfigParser()
pysparse_config.read(os.path.join(top_path, 'site.cfg'))
dflt_lib_dirs = getoption( pysparse_config, 'DEFAULT', 'library_dirs')
if dflt_lib_dirs is None:
dflt_lib_dirs = []
dflt_libs = getoption(pysparse_config, 'DEFAULT', 'libraries')
if dflt_libs is None:
dflt_libs = []
print 'Using dflt_lib_dirs = ', dflt_lib_dirs
print 'Using dflt_libs = ', dflt_libs
config = Configuration('eigen', parent_package, top_path)
# Get BLAS info from site.cfg
blas_info = get_info('blas_opt',0)
if not blas_info:
blas_info = get_info('blas',0)
if not blas_info:
print 'No blas info found'
print 'Eigen:: Using BLAS info:' ; print blas_info
# Get LAPACK info from site.cfg
lapack_info = get_info('lapack_opt',0)
if not lapack_info:
lapack_info = get_info('lapack',0)
if not lapack_info:
print 'No lapack info found'
print 'Eigen:: Using LAPACK info:' ; print lapack_info
jdsym_src = ['jdsymmodule.c']
config.add_extension(
name='jdsym',
sources=[os.path.join('src',name) for name in jdsym_src],
libraries=dflt_libs,
library_dirs=dflt_lib_dirs,
include_dirs=['src'],
extra_info=[blas_info, lapack_info],
)
config.make_config_py()
return config
def matrix_initialize(useBLAS=True):
global useNumpy # module based variable
if useBLAS and useNumpy == None:
print get_info('blas_opt')
try:
linalg.fblas
sys.stderr.write("INFO: using linalg.fblas\n")
useNumpy = False
hasBLAS = True
except AttributeError:
sys.stderr.write("WARNING: linalg.fblas not found, using numpy.dot instead!\n")
useNumpy = True
else:
sys.stderr.write("INFO: using numpy.dot\n")
useNumpy=True
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, get_standard_file, BlasNotFoundError
config = Configuration('glm', parent_package, top_path)
site_cfg = ConfigParser()
site_cfg.read(get_standard_file('site.cfg'))
# cd fast needs CBLAS
blas_info = get_info('blas_opt', 0)
if (not blas_info) or (
('NO_ATLAS_INFO', 1) in blas_info.get('define_macros', [])) :
cblas_libs = ['cblas']
blas_info.pop('libraries', None)
else:
cblas_libs = blas_info.pop('libraries', [])
config.add_extension('cd_fast',
sources=[join('src', 'cd_fast.c')],
libraries=cblas_libs,
include_dirs=[join('..', 'src', 'cblas'),
numpy.get_include(),
blas_info.pop('include_dirs', [])],
extra_compile_args=blas_info.pop('extra_compile_args', []),
**blas_info
)
# add other directories
config.add_subpackage('tests')
config.add_subpackage('benchmarks')
config.add_subpackage('sparse')
return config
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, NotFoundError
config = Configuration('ops',parent_package,top_path)
config.add_extension('apply_window_ext', join('src','apply_window_ext.c'))
config.add_extension('local_extrema_ext', join('src','local_extrema_ext.c'))
config.add_library('fminpack',
sources = [join ('src', 'minpack', '*.f'),
],
)
config.add_extension('regress_ext',
sources = [join('src','regress_ext.c'),
],
)
config.add_extension('acf_ext',
sources = [join('src','acf_ext.c'),
join('src','acf.c')],
libraries = ['fminpack'])
fftw3_info = get_info('fftw3')
if fftw3_info:
config.add_extension('discrete_gauss_ext',
sources = [join('src','discrete_gauss_ext.c'),
join('src','discrete_gauss.c')],
extra_info = fftw3_info)
else:
print 'FFTW3 not found: skipping discrete_gauss_ext extension'
return config
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs
from numpy.distutils.system_info import get_info
from distutils.sysconfig import get_python_inc
config = Configuration('spatial', parent_package, top_path)
config.add_data_dir('tests')
qhull_src = ['geom2.c', 'geom.c', 'global.c', 'io.c', 'libqhull.c',
'mem.c', 'merge.c', 'poly2.c', 'poly.c', 'qset.c',
'random.c', 'rboxlib.c', 'stat.c', 'user.c', 'usermem.c',
'userprintf.c', 'userprintf_rbox.c']
qhull_src = [join('qhull', 'src', x) for x in qhull_src]
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())
cfg = dict(get_info('lapack_opt'))
cfg.setdefault('include_dirs', []).extend(inc_dirs)
cfg.setdefault('define_macros', []).append(('qh_QHpointer','1'))
config.add_extension('qhull',
sources=['qhull.c'] + qhull_src,
**cfg)
config.add_extension('ckdtree', sources=['ckdtree.c']) # FIXME: cython
config.add_extension('_distance_wrap',
sources=[join('src', 'distance_wrap.c')],
depends=[join('src', 'distance_impl.h')],
include_dirs=[get_numpy_include_dirs()])
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('dsolve',parent_package,top_path)
config.add_data_dir('tests')
lapack_opt = get_info('lapack_opt',notfound_action=2)
if sys.platform=='win32':
superlu_defs = [('NO_TIMER',1)]
else:
superlu_defs = []
superlu_defs.append(('USE_VENDOR_BLAS',1))
superlu_src = os.path.join(dirname(__file__), 'SuperLU', 'SRC')
config.add_library('superlu_src',
sources = [join(superlu_src,'*.c')],
macros = superlu_defs,
include_dirs=[superlu_src],
)
# Extension
config.add_extension('_superlu',
sources = ['_superlumodule.c',
'_superlu_utils.c',
'_superluobject.c'],
libraries = ['superlu_src'],
extra_info = lapack_opt,
)
config.add_subpackage('umfpack')
return config
def configuration(parent_package='', top_path=None):
import numpy
from numpy.distutils.misc_util import Configuration
config = Configuration('utils', parent_package, top_path)
config.add_subpackage('sparsetools')
# cd fast needs CBLAS
blas_info = get_info('blas_opt', 0)
if (not blas_info) or (
('NO_ATLAS_INFO', 1) in blas_info.get('define_macros', [])):
cblas_libs = ['cblas']
blas_info.pop('libraries', None)
else:
cblas_libs = blas_info.pop('libraries', [])
config.add_extension('arrayfuncs',
sources=['arrayfuncs.c'],
depends=[join('src', 'cholesky_delete.c')],
libraries=cblas_libs,
include_dirs=[join('..', 'src', 'cblas'),
numpy.get_include(),
blas_info.pop('include_dirs', [])],
extra_compile_args=blas_info.pop('extra_compile_args', []),
**blas_info
)
config.add_extension('graph_shortest_path',
sources=['graph_shortest_path.c'],
include_dirs=[numpy.get_include()])
return config
def configuration(parent_package='',top_path=None):
import numpy
import os
import ConfigParser
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, NotFoundError
# Read relevant PySparse-specific configuration options.
#pysparse_config = ConfigParser.SafeConfigParser()
#pysparse_config.read(os.path.join(top_path, 'site.cfg'))
#hsl_dir = pysparse_config.get('HSL', 'hsl_dir')
config = Configuration('itsolvers', parent_package, top_path)
# Get BLAS info from site.cfg
blas_info = get_info('blas_opt',0)
if not blas_info:
print 'No blas info found'
itsolvers_src = ['itsolversmodule.c', 'bicgstab.c', 'cgs.c', 'gmres.c',
'minres.c', 'pcg.c', 'qmrs.c']
config.add_extension(
name='krylov',
sources=[os.path.join('src',name) for name in itsolvers_src],
libraries=[],
include_dirs=['src'],
extra_info=blas_info,
)
config.make_config_py()
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('solvers',parent_package,top_path)
lapack = dict(get_info('lapack_opt'))
# Branch here for different operating systems
if platform.system() == 'Linux':
config.add_extension('isolab', sources=['src/isolab.pyf',
'src/solab.f90',
'src/isolab.f90'],
libraries=['lapack'],
library_dirs=lapack['library_dirs'])
elif platform.system() == 'Darwin':
lapack['library_dirs'] = ['/usr/lib']
config.add_extension('isolab', sources=['src/isolab.pyf',
'src/solab.f90',
'src/isolab.f90'],
libraries=['lapack'],
library_dirs=lapack['library_dirs'])
elif platform.system() == 'Windows':
config.add_extension('isolab', sources=['src/isolab.pyf',
'src/solab.f90',
'src/isolab.f90'],
libraries=['lapack'],
library_dirs=lapack['library_dirs'])
return config
def configuration(parent_package="", top_path=None):
import warnings
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, BlasNotFoundError
config = Configuration("odr", parent_package, top_path)
libodr_files = ["d_odr.f", "d_mprec.f", "dlunoc.f"]
blas_info = get_info("blas_opt")
if blas_info:
libodr_files.append("d_lpk.f")
else:
warnings.warn(BlasNotFoundError.__doc__)
libodr_files.append("d_lpkbls.f")
libodr = [join("odrpack", x) for x in libodr_files]
config.add_library("odrpack", sources=libodr)
sources = ["__odrpack.c"]
libraries = ["odrpack"] + blas_info.pop("libraries", [])
include_dirs = ["."] + blas_info.pop("include_dirs", [])
config.add_extension(
"__odrpack", sources=sources, libraries=libraries, include_dirs=include_dirs, depends=["odrpack.h"], **blas_info
)
config.add_data_dir("tests")
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
config = Configuration('isolve',parent_package,top_path)
lapack_opt = get_info('lapack_opt')
if not lapack_opt:
raise NotFoundError('no lapack/blas resources found')
# iterative methods
methods = ['BiCGREVCOM.f.src',
'BiCGSTABREVCOM.f.src',
'CGREVCOM.f.src',
'CGSREVCOM.f.src',
# 'ChebyREVCOM.f.src',
'GMRESREVCOM.f.src',
# 'JacobiREVCOM.f.src',
'QMRREVCOM.f.src',
# 'SORREVCOM.f.src'
]
Util = ['STOPTEST2.f.src','getbreak.f.src']
sources = Util + methods + ['_iterative.pyf.src']
config.add_extension('_iterative',
sources = [join('iterative',x) for x in sources],
extra_info = lapack_opt
)
config.add_data_dir('tests')
return config
def configuration (parent_package=''):
package = 'linalg'
config = default_config_dict(package,parent_package)
del config['fortran_libraries']
local_path = get_path(__name__)
atlas_info = get_info('atlas_threads')
if not atlas_info:
atlas_info = get_info('atlas')
if not atlas_info:
raise AtlasNotFoundError(AtlasNotFoundError.__doc__)
ext = Extension('atlas_version',
sources=[os.path.join(local_path,'atlas_version.c')],
libraries=[atlas_info['libraries'][-1]],
library_dirs=atlas_info['library_dirs'])
config['ext_modules'].append(ext)
return config
def configuration(parent_package='', top_path=None):
import warnings
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, BlasNotFoundError
config = Configuration('odr', parent_package, top_path)
libodr_files = ['d_odr.f',
'd_mprec.f',
'dlunoc.f']
blas_info = get_info('blas_opt')
if blas_info:
libodr_files.append('d_lpk.f')
else:
warnings.warn(BlasNotFoundError.__doc__)
libodr_files.append('d_lpkbls.f')
odrpack_src = [join('odrpack', x) for x in libodr_files]
config.add_library('odrpack', sources=odrpack_src)
sources = ['__odrpack.c']
libraries = ['odrpack'] + blas_info.pop('libraries', [])
include_dirs = ['.'] + blas_info.pop('include_dirs', [])
config.add_extension('__odrpack',
sources=sources,
libraries=libraries,
include_dirs=include_dirs,
depends=(['odrpack.h'] + odrpack_src),
**blas_info
)
config.add_data_dir('tests')
return config
def make_extension(**extra):
def parse_define(define):
index = define.find('=')
if index < 0:
return (define, None)
else:
return define[:index], define[index + 1:]
extension = {
"define_macros": cfg.get('compiler', 'defines').split(),
"undef_macros": cfg.get('compiler', 'undefs').split(),
"include_dirs": cfg.get('compiler', 'include_dirs').split(),
"library_dirs": cfg.get('compiler', 'library_dirs').split(),
"libraries": cfg.get('compiler', 'libs').split(),
"extra_compile_args": cfg.get('compiler', 'cflags').split(),
"extra_link_args": cfg.get('compiler', 'ldflags').split(),
}
extension['define_macros'].append('ENABLE_PYTHON_MODULE')
here = os.path.dirname(os.path.dirname(__file__)) or '.'
# using / as separator as advised in the distutils doc
extension["include_dirs"].append(here + '/pythran')
for k, w in extra.items():
extension[k].extend(w)
extension["define_macros"] = map(parse_define, extension["define_macros"])
if cfg.getboolean('pythran', 'complex_hook'):
# the patch is *not* portable
extension["include_dirs"].append(here + '/pythran/pythonic/patch')
# blas dependency
numpy_blas = numpy_sys.get_info("blas")
extension['libraries'].extend(numpy_blas.get('libraries', []))
extension['library_dirs'].extend(numpy_blas.get('library_dirs', []))
return extension
def configuration(parent_package='',top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info
config = Configuration('linalg',parent_package,top_path)
config.add_data_dir('tests')
# Configure lapack_lite
lapack_info = get_info('lapack_opt',0) # and {}
def get_lapack_lite_sources(ext, build_dir):
if not lapack_info:
print("### Warning: Using unoptimized lapack ###")
return ext.depends[:-1]
else:
if sys.platform=='win32':
print("### Warning: python_xerbla.c is disabled ###")
return ext.depends[:1]
return ext.depends[:2]
config.add_extension('lapack_lite',
sources = [get_lapack_lite_sources],
depends= ['lapack_litemodule.c',
'python_xerbla.c',
'zlapack_lite.c', 'dlapack_lite.c',
'blas_lite.c', 'dlamch.c',
'f2c_lite.c','f2c.h'],
extra_info = lapack_info
)
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
from numpy.distutils.system_info import get_info
blas_info = get_info('blas_opt', 0)
if (not blas_info) or (
('NO_ATLAS_INFO', 1) in blas_info.get('define_macros', [])):
cblas_libs = ['cblas']
blas_info.pop('libraries', None)
else:
cblas_libs = blas_info.pop('libraries', [])
config = Configuration('cluster', parent_package, top_path)
config.add_extension(
'_inertia',
sources=['_inertia.c'],
include_dirs=[numpy.get_include()],
)
config.add_extension(
'_k_means',
libraries=cblas_libs,
sources=['_k_means.c'],
include_dirs=[join('..', 'src', 'cblas'),
numpy.get_include(),
blas_info.pop('include_dirs', [])],
extra_compile_args=blas_info.pop('extra_compile_args', []),
**blas_info
)
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('pycsdp', parent_package, top_path)
##########################################################################
# Adjust the libname (so libsdp.so/a <-> sdp), the library path and
# provide the location of the "declarations.h" file.
##########################################################################
libname = 'sdp'
library_dir = [SAGE_LIB]
includes = [SAGE_INCLUDE, SAGE_INCLUDE+'/csdp', '.']
sources = [join('Src/','*.cxx'),
join('Src/','*.c'),
'_csdp.cpp']
lapack_opt = get_info('lapack_opt')
config.add_extension('_csdp',
sources = sources,
include_dirs = includes,
library_dirs = library_dir,
extra_compile_args = ['-funroll-loops'],
define_macros = [('NOSHORTS',None)],
libraries = [libname],
extra_info = lapack_opt)
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
# Taken from https://gist.github.com/alimuldal/eb0f4eea8af331b2a890
import numpy
from numpy.distutils.system_info import get_info
import sys
import timeit
print("version: %s" % numpy.__version__)
print("maxint: %i\n" % sys.maxint)
info = get_info('blas_opt')
print('BLAS info:')
for kk, vv in info.iteritems():
print(' * ' + kk + ' ' + str(vv))
setup = "import numpy; x = numpy.random.random((1000, 1000))"
count = 10
t = timeit.Timer("numpy.dot(x, x.T)", setup=setup)
print("\ndot: %f sec" % (t.timeit(count) / count))
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,
generate_ufunc_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'),
]
if '__pypy__' not in sys.builtin_module_names:
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', '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)
if '__pypy__' not in sys.builtin_module_names:
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'))
if '__pypy__' not in sys.builtin_module_names:
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 #
#######################################################################
if '__pypy__' not in sys.builtin_module_names:
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[:1]
return None # no extension module will be built
if '__pypy__' not in sys.builtin_module_names:
config.add_extension('_dotblas',
sources=[get_dotblas_sources],
depends=[
join('blasdot', '_dotblas.c'),
join('blasdot', 'cblas.h'),
],
include_dirs=['blasdot'],
extra_info=blas_info)
#######################################################################
# umath_tests module #
#######################################################################
if '__pypy__' not in sys.builtin_module_names:
config.add_extension(
'umath_tests', sources=[join('src', 'umath', 'umath_tests.c.src')])
#######################################################################
# custom rational dtype module #
#######################################################################
if '__pypy__' not in sys.builtin_module_names:
config.add_extension(
'test_rational',
sources=[join('src', 'umath', 'test_rational.c.src')])
#######################################################################
# struct_ufunc_test module #
#######################################################################
if '__pypy__' not in sys.builtin_module_names:
config.add_extension(
'struct_ufunc_test',
sources=[join('src', 'umath', 'struct_ufunc_test.c.src')])
#######################################################################
# multiarray_tests module #
#######################################################################
if '__pypy__' not in sys.builtin_module_names:
config.add_extension(
'multiarray_tests',
sources=[join('src', 'multiarray', 'multiarray_tests.c.src')])
#######################################################################
# operand_flag_tests module #
#######################################################################
if '__pypy__' not in sys.builtin_module_names:
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, 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
rep = check_long_double_representation(config_cmd)
moredefs.append(('HAVE_LDOUBLE_%s' % rep, 1))
# 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 common include directory in build_dir on search path
# allows using code generation in headers 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
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", "common"))
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([
("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 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:
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', 'heapsort.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'),
]
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'),
]
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.
common_src.extend([
join('src', 'common', 'cblasfuncs.c'),
join('src', 'common', 'python_xerbla.c'),
])
if uses_accelerate_framework(blas_info):
common_src.extend(get_sgemv_fix())
else:
extra_info = {}
#######################################################################
# _multiarray_umath module - multiarray part #
#######################################################################
multiarray_deps = [
join('src', 'multiarray', 'arrayobject.h'),
join('src', 'multiarray', 'arraytypes.h'),
join('src', 'multiarray', 'arrayfunction_override.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', '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', 'alloc.c'),
join('src', 'multiarray', 'arrayobject.c'),
join('src', 'multiarray', 'arraytypes.c.src'),
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', '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):
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', 'matmul.h.src'),
join('src', 'umath', 'matmul.c.src'),
join('src', 'umath', 'ufunc_object.c'),
join('src', 'umath', 'extobj.c'),
join('src', 'umath', 'cpuid.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')])
#######################################################################
# 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_data_dir('tests')
config.add_data_dir('tests/data')
config.make_svn_version_py()
return config
#from Cython.Distutils import build_ext
base_path = os.path.abspath(os.path.dirname(__file__))
lapack_opt = None
def win():
"""
Return True if a windows system
"""
if platform.system() in ["Windows", "win32"]:
return True
return False
if not win():
try:
lapack_opt = get_info('lapack_opt',notfound_action=2)
except:
print('LAPACK not found, no sundials solvers')
if win():
print ('In win')
INCL_DIRS_LAPACK = ['C:/MinGW/lib/Lapack/lapack-3.4.1/SRC']
LIB_DIRS_LAPACK = ['C:/MinGW/lib/Lapack/lib']
LIBS_LAPACK = ['lapack', 'blas']
INCL_DIRS_SUNDIALS = ['C:/Program Files/sundials/include']
LIB_DIRS_SUNDIALS = ['C:/Program Files/sundials', 'C:/Program Files/sundials/lib']
LIBS_SUNDIALS = ['sundials_nvecserial']
LIBS_IDA = ['sundials_ida']
LIBS_CVODE = ['sundials_cvode']
LIB_DIRS_GFORTRAN = ['C:/MinGW/lib/gcc/mingw32/4.6.2']
LIBS_FORTRAN = ['gfortran']
VERSION_FILE_PATH = os.path.join(BASE_PATH, '_version.py')
C_SRC_PATH = os.path.join(BASE_PATH, 'src')
LAPACK_LITE_PATH = os.path.join(C_SRC_PATH, 'lapack_lite')
versioneer.versionfile_source = VERSION_FILE_PATH
versioneer.versionfile_build = VERSION_FILE_PATH
versioneer.tag_prefix = ''
versioneer.parentdir_prefix = 'gulinalg-'
# Use information about the LAPACK library used in NumPy.
# if not present, fallback to using the included lapack-lite
MODULE_SOURCES = [os.path.join(C_SRC_PATH, 'gulinalg.c.src')]
MODULE_DEPENDENCIES = copy.copy(MODULE_SOURCES)
lapack_info = np_sys_info.get_info('lapack_opt', 0)
lapack_lite_files = [
os.path.join(LAPACK_LITE_PATH, f) for f in [
'python_xerbla.c', 'zlapack_lite.c', 'dlapack_lite.c', 'blas_lite.c',
'dlamch.c', 'f2c_lite.c', 'f2c.h'
]
]
if not lapack_info:
# No LAPACK in NumPy
print('### Warning: Using unoptimized blas/lapack @@@')
MODULE_SOURCES.extend(lapack_lite_files[:-1]) # all but f2c.h
MODULE_DEPENDENCIES.extend(lapack_lite_files)
else:
if sys.platform == 'win32':
print('### Warning: python.xerbla.c is disabled ###')
def make_extension(python, **extra):
# load platform specific configuration then user configuration
cfg = init_cfg('pythran.cfg', 'pythran-{}.cfg'.format(sys.platform),
'.pythranrc', extra.get('config', None))
if 'config' in extra:
extra.pop('config')
def parse_define(define):
index = define.find('=')
if index < 0:
return (define, None)
else:
return define[:index], define[index + 1:]
extension = {
"language":
"c++",
# forcing str conversion to handle Unicode case (the default on MS)
"define_macros":
[str(x) for x in cfg.get('compiler', 'defines').split()],
"undef_macros":
[str(x) for x in cfg.get('compiler', 'undefs').split()],
"include_dirs":
[str(x) for x in cfg.get('compiler', 'include_dirs').split()],
"library_dirs":
[str(x) for x in cfg.get('compiler', 'library_dirs').split()],
"libraries": [str(x) for x in cfg.get('compiler', 'libs').split()],
"extra_compile_args":
[str(x) for x in cfg.get('compiler', 'cflags').split()],
"extra_link_args":
[str(x) for x in cfg.get('compiler', 'ldflags').split()],
"extra_objects": []
}
if python:
extension['define_macros'].append('ENABLE_PYTHON_MODULE')
extension['define_macros'].append('__PYTHRAN__={}'.format(
sys.version_info.major))
here = os.path.dirname(os.path.dirname(__file__)) or '.'
# using / as separator as advised in the distutils doc
extension["include_dirs"].append(here + '/pythran')
extra.pop('language', None) # forced to c++ anyway
cxx = extra.pop('cxx', None)
cc = extra.pop('cc', None)
if cxx is None:
cxx = compiler()
if cxx is not None:
extension['cxx'] = cxx
extension['cc'] = cc or cxx
for k, w in extra.items():
extension[k].extend(w)
if cfg.getboolean('pythran', 'complex_hook'):
# the patch is *not* portable
extension["include_dirs"].append(here + '/pythran/pythonic/patch')
# Numpy can pollute stdout with warning message which should be on stderr
old_stdout = sys.stdout
try:
sys.stdout = sys.stderr
# numpy specific
if python:
extension['include_dirs'].append(numpy.get_include())
# blas dependency
reserved_blas_entries = 'pythran-openblas', 'none'
user_blas = cfg.get('compiler', 'blas')
if user_blas == 'pythran-openblas':
try:
import pythran_openblas as openblas
# required to cope with atlas missing extern "C"
extension['define_macros'].append('PYTHRAN_BLAS_OPENBLAS')
extension['include_dirs'].extend(openblas.include_dirs)
extension['extra_objects'].append(
os.path.join(openblas.library_dir,
openblas.static_library))
except ImportError:
logger.warning("Failed to find 'pythran-openblas' package. "
"Please install it or change the compiler.blas "
"setting. Defaulting to 'blas'")
user_blas = 'blas'
elif user_blas == 'none':
extension['define_macros'].append('PYTHRAN_BLAS_NONE')
if user_blas not in reserved_blas_entries:
numpy_blas = numpy_sys.get_info(user_blas)
# required to cope with atlas missing extern "C"
extension['define_macros'].append('PYTHRAN_BLAS_{}'.format(
user_blas.upper()))
extension['libraries'].extend(numpy_blas.get('libraries', []))
extension['library_dirs'].extend(numpy_blas.get(
'library_dirs', []))
extension['include_dirs'].extend(numpy_blas.get(
'include_dirs', []))
finally:
sys.stdout = old_stdout
# final macro normalization
extension["define_macros"] = [
dm if isinstance(dm, tuple) else parse_define(dm)
for dm in extension["define_macros"]
]
return extension
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info
config = Configuration('lapack', parent_package, top_path)
lapack_opt = get_info('lapack_opt', notfound_action=2)
atlas_version = ([v[3:-3] for k,v in lapack_opt.get('define_macros',[]) \
if k=='ATLAS_INFO']+[None])[0]
if atlas_version:
print('ATLAS version: %s' % atlas_version)
target_dir = ''
skip_names = {'clapack': [], 'flapack': []}
if skip_single_routines:
target_dir = 'dbl'
skip_names['clapack'].extend(\
'sgesv cgesv sgetrf cgetrf sgetrs cgetrs sgetri cgetri'\
' sposv cposv spotrf cpotrf spotrs cpotrs spotri cpotri'\
' slauum clauum strtri ctrtri'.split())
skip_names['flapack'].extend(skip_names['clapack'])
skip_names['flapack'].extend(\
'sgesdd cgesdd sgelss cgelss sgeqrf cgeqrf sgeev cgeev'\
' sgegv cgegv ssyev cheev slaswp claswp sgees cgees'
' sggev cggev'.split())
if atlas_version == '3.2.1_pre3.3.6':
target_dir = os.path.join(target_dir, 'atlas321')
skip_names['clapack'].extend(\
'sgetri dgetri cgetri zgetri spotri dpotri cpotri zpotri'\
' slauum dlauum clauum zlauum strtri dtrtri ctrtri ztrtri'.split())
elif atlas_version and atlas_version > '3.4.0' and atlas_version <= '3.5.12':
skip_names['clapack'].extend('cpotrf zpotrf'.split())
# flapack:
config.add_extension('flapack',
sources=['flapack.pyf.src'],
depends=[__file__, 'flapack_*.pyf.src'],
f2py_options=['skip:'] + skip_names['flapack'] +
[':'],
extra_info=lapack_opt)
# clapack:
def get_clapack_source(ext, build_dir):
name = ext.name.split('.')[-1]
assert name == 'clapack', repr(name)
if atlas_version is None:
target = os.path.join(build_dir, target_dir, 'clapack.pyf')
from distutils.dep_util import newer
if newer(__file__, target):
f = open(target, 'w')
f.write(tmpl_empty_clapack_pyf)
f.close()
else:
target = ext.depends[0]
assert os.path.basename(target) == 'clapack.pyf.src'
return target
config.add_extension('clapack',
sources=[get_clapack_source],
depends=['clapack.pyf.src'],
f2py_options=['skip:'] + skip_names['clapack'] +
[':'],
extra_info=lapack_opt)
# calc_lwork:
config.add_extension('calc_lwork',
sources=['calc_lwork.f'],
extra_info=lapack_opt)
# atlas_version:
if os.name == 'nt' and 'FPATH' in os.environ:
define_macros = [('NO_ATLAS_INFO', 1)]
else:
define_macros = []
config.add_extension('atlas_version',
sources=['atlas_version.c'],
extra_info=lapack_opt,
define_macros=define_macros)
config.add_data_dir('tests')
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('integrate', parent_package, top_path)
blas_opt = get_info('blas_opt', notfound_action=2)
linpack_lite_src = [join('linpack_lite', '*.f')]
mach_src = [join('mach', '*.f')]
quadpack_src = [join('quadpack', '*.f')]
odepack_src = [join('odepack', '*.f')]
dop_src = [join('dop', '*.f')]
quadpack_test_src = [join('tests', '_test_multivariate.c')]
config.add_library('linpack_lite', sources=linpack_lite_src)
config.add_library('mach',
sources=mach_src,
config_fc={'noopt': (__file__, 1)})
config.add_library('quadpack', sources=quadpack_src)
config.add_library('odepack', sources=odepack_src)
config.add_library('dop', sources=dop_src)
# should we try to weed through files and replace with calls to
# LAPACK routines?
# Yes, someday...
# Extensions
# quadpack:
config.add_extension('_quadpack',
sources=['_quadpackmodule.c'],
libraries=['quadpack', 'linpack_lite', 'mach'],
depends=(['quadpack.h', '__quadpack.h'] +
quadpack_src + linpack_lite_src + mach_src))
# odepack
libs = ['odepack', 'linpack_lite', 'mach']
# Remove libraries key from blas_opt
if 'libraries' in blas_opt: # key doesn't exist on OS X ...
libs.extend(blas_opt['libraries'])
newblas = {}
for key in blas_opt:
if key == 'libraries':
continue
newblas[key] = blas_opt[key]
config.add_extension('_odepack',
sources=['_odepackmodule.c'],
libraries=libs,
depends=(['__odepack.h', 'multipack.h'] +
odepack_src + linpack_lite_src + mach_src),
**newblas)
# vode
config.add_extension('vode',
sources=['vode.pyf'],
libraries=libs,
depends=(odepack_src + linpack_lite_src + mach_src),
**newblas)
# lsoda
config.add_extension('lsoda',
sources=['lsoda.pyf'],
libraries=libs,
depends=(odepack_src + linpack_lite_src + mach_src),
**newblas)
# dop
config.add_extension('_dop',
sources=['dop.pyf'],
libraries=['dop'],
depends=dop_src)
config.add_extension('_test_multivariate', sources=quadpack_test_src)
config.add_data_dir('tests')
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('integrate', parent_package, top_path)
# Get a local copy of lapack_opt_info
lapack_opt = dict(get_info('lapack_opt', notfound_action=2))
# Pop off the libraries list so it can be combined with
# additional required libraries
lapack_libs = lapack_opt.pop('libraries', [])
mach_src = [join('mach', '*.f')]
quadpack_src = [join('quadpack', '*.f')]
lsoda_src = [
join('odepack', fn) for fn in [
'blkdta000.f', 'bnorm.f', 'cfode.f', 'ewset.f', 'fnorm.f',
'intdy.f', 'lsoda.f', 'prja.f', 'solsy.f', 'srcma.f', 'stoda.f',
'vmnorm.f', 'xerrwv.f', 'xsetf.f', 'xsetun.f'
]
]
vode_src = [join('odepack', 'vode.f'), join('odepack', 'zvode.f')]
dop_src = [join('dop', '*.f')]
quadpack_test_src = [join('tests', '_test_multivariate.c')]
odeint_banded_test_src = [join('tests', 'banded5x5.f')]
config.add_library('mach',
sources=mach_src,
config_fc={'noopt': (__file__, 1)})
config.add_library('quadpack', sources=quadpack_src)
config.add_library('lsoda', sources=lsoda_src)
config.add_library('vode', sources=vode_src)
config.add_library('dop', sources=dop_src)
# Extensions
# quadpack:
include_dirs = [join(os.path.dirname(__file__), '..', '_lib', 'src')]
if 'include_dirs' in lapack_opt:
lapack_opt = dict(lapack_opt)
include_dirs.extend(lapack_opt.pop('include_dirs'))
config.add_extension('_quadpack',
sources=['_quadpackmodule.c'],
libraries=['quadpack', 'mach'] + lapack_libs,
depends=(['__quadpack.h'] + quadpack_src + mach_src),
include_dirs=include_dirs,
**lapack_opt)
# odepack/lsoda-odeint
odepack_opts = lapack_opt.copy()
odepack_opts.update(numpy_nodepr_api)
config.add_extension('_odepack',
sources=['_odepackmodule.c'],
libraries=['lsoda', 'mach'] + lapack_libs,
depends=(lsoda_src + mach_src),
**odepack_opts)
# vode
config.add_extension('vode',
sources=['vode.pyf'],
libraries=['vode'] + lapack_libs,
depends=vode_src,
**lapack_opt)
# lsoda
config.add_extension('lsoda',
sources=['lsoda.pyf'],
libraries=['lsoda', 'mach'] + lapack_libs,
depends=(lsoda_src + mach_src),
**lapack_opt)
# dop
config.add_extension('_dop',
sources=['dop.pyf'],
libraries=['dop'],
depends=dop_src)
config.add_extension('_test_multivariate', sources=quadpack_test_src)
# Fortran+f2py extension module for testing odeint.
config.add_extension('_test_odeint_banded',
sources=odeint_banded_test_src,
libraries=['lsoda', 'mach'] + lapack_libs,
depends=(lsoda_src + mach_src),
**lapack_opt)
config.add_subpackage('_ivp')
config.add_data_dir('tests')
return config
def find_version(*paths):
fname = os.path.join(os.path.dirname(__file__), *paths)
with open(fname, encoding='utf-8') as fp:
code = fp.read()
match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", code, re.M)
if match:
return match.group(1)
raise RuntimeError("Unable to find version string.")
ext = [
Extension(name='telewavesim.rmat_f',
sources=['src/rmat.f90', 'src/rmat_sub.f90'],
libraries=['lapack'],
library_dirs=get_info('lapack_opt', 1).get('library_dirs'))
]
setup(name='telewavesim',
version=find_version('telewavesim', '__init__.py'),
description='Python package for teleseismic body-wave modeling',
author='Pascal Audet, Colin J. Thomson, Michael G. Bostock',
maintainer='Pascal Audet',
author_email='*****@*****.**',
url='https://github.com/paudetseis/Telewavesim',
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Fortran',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
env_vars = {}
if env_lib_dirs:
env_vars['library_dirs'] = env_lib_dirs.split(':')
if env_libs:
env_vars['libraries'] = env_libs.split(':')
install_scs(USE_64_BIT_BLAS=USE_64_BIT_BLAS,
blas_info=env_vars,
lapack_info={},
USE_OPENMP=USE_OPENMP,
rootDir=rootDir)
else:
# environment variables not set, using defaults instead
try:
print("using blas_opt / lapack_opt")
install_scs(USE_64_BIT_BLAS=USE_64_BIT_BLAS,
blas_info=get_info('blas_opt'),
lapack_info=get_info('lapack_opt'),
USE_OPENMP=USE_OPENMP,
rootDir=rootDir)
except SystemExit as e: # catch permission denied error
print("SystemExit")
print(e)
except:
# print("error:", sys.exc_info()[0])
print("blas_opt / lapack_opt install failed, trying blas / lapack")
try:
install_scs(USE_64_BIT_BLAS=USE_64_BIT_BLAS,
blas_info=get_info('blas'),
lapack_info=get_info('lapack'),
USE_OPENMP=USE_OPENMP,
rootDir=rootDir)
def run_compile():
"""
Do it all in one call!
"""
import tempfile, os, shutil
i = sys.argv.index('-c')
del sys.argv[i]
remove_build_dir = 0
try:
i = sys.argv.index('--build-dir')
except ValueError:
i = None
if i is not None:
build_dir = sys.argv[i + 1]
del sys.argv[i + 1]
del sys.argv[i]
else:
remove_build_dir = 1
build_dir = os.path.join(tempfile.mktemp())
sysinfo_flags = filter(re.compile(r'[-][-]link[-]').match, sys.argv[1:])
sys.argv = filter(lambda a, flags=sysinfo_flags: a not in flags, sys.argv)
if sysinfo_flags:
sysinfo_flags = [f[7:] for f in sysinfo_flags]
f2py_flags = filter(
re.compile(
r'[-][-]((no[-]|)(wrap[-]functions|lower)|debug[-]capi|quiet)|[-]include'
).match, sys.argv[1:])
sys.argv = filter(lambda a, flags=f2py_flags: a not in flags, sys.argv)
f2py_flags2 = []
fl = 0
for a in sys.argv[1:]:
if a in ['only:', 'skip:']:
fl = 1
elif a == ':':
fl = 0
if fl or a == ':':
f2py_flags2.append(a)
if f2py_flags2 and f2py_flags2[-1] != ':':
f2py_flags2.append(':')
f2py_flags.extend(f2py_flags2)
sys.argv = filter(lambda a, flags=f2py_flags2: a not in flags, sys.argv)
flib_flags = filter(
re.compile(
r'[-][-]((f(90)?compiler([-]exec|)|compiler)=|help[-]compiler)').
match, sys.argv[1:])
sys.argv = filter(lambda a, flags=flib_flags: a not in flags, sys.argv)
fc_flags = filter(
re.compile(
r'[-][-]((f(77|90)(flags|exec)|opt|arch)=|(debug|noopt|noarch|help[-]fcompiler))'
).match, sys.argv[1:])
sys.argv = filter(lambda a, flags=fc_flags: a not in flags, sys.argv)
if 1:
del_list = []
for s in flib_flags:
v = '--fcompiler='
if s[:len(v)] == v:
from numpy.distutils import fcompiler
allowed_keys = fcompiler.fcompiler_class.keys()
nv = ov = s[len(v):].lower()
if ov not in allowed_keys:
vmap = {} # XXX
try:
nv = vmap[ov]
except KeyError:
if ov not in vmap.values():
print 'Unknown vendor: "%s"' % (s[len(v):])
nv = ov
i = flib_flags.index(s)
flib_flags[i] = '--fcompiler=' + nv
continue
for s in del_list:
i = flib_flags.index(s)
del flib_flags[i]
assert len(flib_flags) <= 2, ` flib_flags `
setup_flags = filter(re.compile(r'[-][-](verbose)').match, sys.argv[1:])
sys.argv = filter(lambda a, flags=setup_flags: a not in flags, sys.argv)
if '--quiet' in f2py_flags:
setup_flags.append('--quiet')
modulename = 'untitled'
sources = sys.argv[1:]
if '-m' in sys.argv:
i = sys.argv.index('-m')
modulename = sys.argv[i + 1]
del sys.argv[i + 1], sys.argv[i]
sources = sys.argv[1:]
else:
from numpy.distutils.command.build_src import get_f2py_modulename
pyf_files, sources = filter_files('', '[.]pyf([.]src|)', sources)
sources = pyf_files + sources
for f in pyf_files:
modulename = get_f2py_modulename(f)
if modulename:
break
extra_objects, sources = filter_files('', '[.](o|a|so)', sources)
include_dirs, sources = filter_files('-I', '', sources, remove_prefix=1)
library_dirs, sources = filter_files('-L', '', sources, remove_prefix=1)
libraries, sources = filter_files('-l', '', sources, remove_prefix=1)
undef_macros, sources = filter_files('-U', '', sources, remove_prefix=1)
define_macros, sources = filter_files('-D', '', sources, remove_prefix=1)
using_numarray = 0
using_numeric = 0
for i in range(len(define_macros)):
name_value = string.split(define_macros[i], '=', 1)
if len(name_value) == 1:
name_value.append(None)
if len(name_value) == 2:
define_macros[i] = tuple(name_value)
else:
print 'Invalid use of -D:', name_value
from numpy.distutils.system_info import get_info
num_include_dir = None
num_info = {}
#import numpy
#n = 'numpy'
#p = get_prefix(numpy)
#from numpy.distutils.misc_util import get_numpy_include_dirs
#num_info = {'include_dirs': get_numpy_include_dirs()}
if num_info:
include_dirs.extend(num_info.get('include_dirs', []))
from numpy.distutils.core import setup, Extension
ext_args = {
'name': modulename,
'sources': sources,
'include_dirs': include_dirs,
'library_dirs': library_dirs,
'libraries': libraries,
'define_macros': define_macros,
'undef_macros': undef_macros,
'extra_objects': extra_objects,
'f2py_options': f2py_flags,
}
if sysinfo_flags:
from numpy.distutils.misc_util import dict_append
for n in sysinfo_flags:
i = get_info(n)
if not i:
outmess('No %s resources found in system'\
' (try `f2py --help-link`)\n' % (`n`))
dict_append(ext_args, **i)
ext = Extension(**ext_args)
sys.argv = [sys.argv[0]] + setup_flags
sys.argv.extend([
'build', '--build-temp', build_dir, '--build-base', build_dir,
'--build-platlib', '.'
])
if fc_flags:
sys.argv.extend(['config_fc'] + fc_flags)
if flib_flags:
sys.argv.extend(['build_ext'] + flib_flags)
setup(ext_modules=[ext])
if remove_build_dir and os.path.exists(build_dir):
outmess('Removing build directory %s\n' % (build_dir))
shutil.rmtree(build_dir)
'platforms': ['linux'],
'requires': ['obspy', 'basemap'],
'py_modules': [
'seispy.burrow', 'seispy.event', 'seispy.gather', 'seispy.geoid',
'seispy.geometry', 'seispy.locate', 'seispy.network', 'seispy.station',
'seispy.trace', 'seispy.ttgrid', 'seispy.util', 'seispy.velocity'
],
'scripts': [
'scripts/fetch_data', 'scripts/fm3d_ttimes', 'scripts/mt-3dloc',
'scripts/mt-shear', 'scripts/mt-synth', 'scripts/plot_events',
'scripts/synthetics2db'
]
}
# Get some information about BLAS and LAPACK libraries.
blas_opt = get_info('blas', notfound_action=2)
lapack_opt = get_info('lapack', notfound_action=2)
# Compile resource information needed by seispy.signal.statistics module.
config_path = "%s/lib/python%d.%d/config" % (
sys.prefix, sys.version_info.major, sys.version_info.minor)
libs = [blas_opt['libraries'][0], lapack_opt['libraries'][0]]
lib_dirs = [
blas_opt['library_dirs'][0], lapack_opt['library_dirs'][0], config_path
]
# Compile resource information needed by seispy.signal.detect module
eigen_path = os.getcwd() + "/seispy/signal/src"
# Add statistics and detect extension modules from the seispy.signal
# sub-module.
kwargs['ext_modules'] = [
Extension('seispy.signal.statistics', ['seispy/signal/statistics.f90'],
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info, BlasNotFoundError
import numpy
libraries = []
if os.name == 'posix':
libraries.append('m')
config = Configuration('sklearn', parent_package, top_path)
config.add_subpackage('__check_build')
config.add_subpackage('svm')
config.add_subpackage('datasets')
config.add_subpackage('datasets/tests')
config.add_subpackage('feature_extraction')
config.add_subpackage('feature_extraction/tests')
config.add_subpackage('cluster')
config.add_subpackage('cluster/tests')
config.add_subpackage('cluster/bicluster')
config.add_subpackage('cluster/bicluster/tests')
config.add_subpackage('covariance')
config.add_subpackage('covariance/tests')
config.add_subpackage('cross_decomposition')
config.add_subpackage('decomposition')
config.add_subpackage('decomposition/tests')
config.add_subpackage("ensemble")
config.add_subpackage("ensemble/tests")
config.add_subpackage('feature_selection')
config.add_subpackage('feature_selection/tests')
config.add_subpackage('utils')
config.add_subpackage('utils/tests')
config.add_subpackage('externals')
config.add_subpackage('mixture')
config.add_subpackage('mixture/tests')
config.add_subpackage('gaussian_process')
config.add_subpackage('gaussian_process/tests')
config.add_subpackage('neighbors')
config.add_subpackage('neural_network')
config.add_subpackage('preprocessing')
config.add_subpackage('manifold')
config.add_subpackage('metrics')
config.add_subpackage('semi_supervised')
config.add_subpackage("tree")
config.add_subpackage("tree/tests")
config.add_subpackage('metrics/tests')
config.add_subpackage('metrics/cluster')
config.add_subpackage('metrics/cluster/tests')
# add cython extension module for hmm
config.add_extension(
'_hmmc',
sources=['_hmmc.c'],
include_dirs=[numpy.get_include()],
libraries=libraries,
)
config.add_extension(
'_isotonic',
sources=['_isotonic.c'],
include_dirs=[numpy.get_include()],
libraries=libraries,
)
# some libs needs cblas, fortran-compiled BLAS will not be sufficient
blas_info = get_info('blas_opt', 0)
if (not blas_info) or (('NO_ATLAS_INFO', 1) in blas_info.get(
'define_macros', [])):
config.add_library('cblas', sources=[join('src', 'cblas', '*.c')])
warnings.warn(BlasNotFoundError.__doc__)
# the following packages depend on cblas, so they have to be build
# after the above.
config.add_subpackage('linear_model')
config.add_subpackage('utils')
# add the test directory
config.add_subpackage('tests')
return config
def _has_blas_lib(libname):
from numpy.distutils.system_info import get_info
return libname in get_info('blas_opt').get('libraries', [])
"""
def build_extension(self, ext):
pass
if cython:
# we have cython and generate c codes directly
suffix = ".pyx"
cmdclass["cython"] = CythonCommand
else:
suffix = ".c"
# Retrieve the compiler information
from numpy.distutils.system_info import get_info
# use flags defined in numpy
all_info = get_info('ALL')
# Define compilation flags
extra_compile_args = ""
extra_link_args = extra_compile_args
# in numpy>=1.16.0, silence build warnings about deprecated API usage
macros.append(("NPY_NO_DEPRECATED_API", "0"))
# Do not expose multiple platform Cython code.
# We do not need it
# https://cython.readthedocs.io/en/latest/src/userguide/source_files_and_compilation.html#integrating-multiple-modules
macros.append(("CYTHON_NO_PYINIT_EXPORT", "1"))
class EnsureSource_sdist(sdist):
"""Ensure Cython has runned on all pyx files (i.e. we need c sources)."""
def find_version(*paths):
fname = os.path.join(os.path.dirname(__file__), *paths)
with open(fname) as fp:
code = fp.read()
match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", code, re.M)
if match:
return match.group(1)
raise RuntimeError("Unable to find version string.")
ext_cpwt = Extension(name='plateflex.cpwt',
sources=['src/cpwt/cpwt.f90', 'src/cpwt/cpwt_sub.f90'],
libraries=['gfortran'],
library_dirs=get_info('gfortran').get('library_dirs'))
ext_flex = Extension(name='plateflex.flex',
sources=['src/flex/flex.f90'],
libraries=['gfortran'],
library_dirs=get_info('gfortran').get('library_dirs'))
setup(
name='plateflex',
version=find_version('plateflex', '__init__.py'),
description='Python package for estimating lithospheric elastic thickness',
author='Pascal Audet',
maintainer='Pascal Audet',
author_email='*****@*****.**',
url='https://github.com/paudetseis/PlateFlex',
classifiers=[
'Development Status :: 3 - Alpha',
from warnings import warn
from numpy.distutils.system_info import get_info
# should synthesizeNTF run the optimization routine?
optimize_NTF = True
# how many iterations should be allowed in NTF synthesis?
# see synthesizeNTF() for more
itn_limit = 500
# debug
_debug = False
# get blas information to compile the cython extensions
blas_info = get_info("blas")
if len(blas_info) == 0 and _debug:
warn("Numpy did not detect the BLAS library in the system")
# Let's make an educated guess
if 'linux' in sys.platform or 'darwin' in sys.platform:
guessed_include = '/usr/include'
else:
guessed_include = None
# wrap it up: numpy or user-set environment var or a lucky guess on our side is
# needed to get the cblas.h header path. If not found, simulateDSM() will use
# a CPython implementation (slower).
setup_args = {
"script_args": (["--compiler=mingw32"] if sys.platform == 'win32' else [])
}
lib_include = [np.get_include()]
if "include_dirs" not in blas_info and "BLAS_H" not in os.environ and \
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
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'}
if sys.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.c.src', get_lapack_lite_sources],
depends=['lapack_lite/f2c.h'],
extra_info=lapack_info,
libraries=['npymath'],
)
config.add_data_files('*.pyi')
return config
def get_extensions():
try:
from numpy.distutils.system_info import get_info
mkl_info = get_info('mkl')
except ImportError:
mkl_root = os.environ['MKLROOT']
mkl_info = {
'include_dirs': [join(mkl_root, 'include')],
'library_dirs': [join(mkl_root, 'lib'), join(mkl_root, 'lib', 'intel64')],
'libraries': ['mkl_rt']
}
mkl_include_dirs = mkl_info.get('include_dirs', [])
mkl_library_dirs = mkl_info.get('library_dirs', [])
mkl_libraries = mkl_info.get('libraries', ['mkl_rt'])
defs = []
if any(['mkl_rt' in li for li in mkl_libraries]):
#libs += ['dl'] - by default on Linux
defs += [('USING_MKL_RT', None)]
pdir = 'mkl'
try:
from Cython.Build import cythonize
sources = [join(pdir, '_mkl_service.pyx')]
have_cython = True
except ImportError as e:
have_cython = False
sources = [join(pdir, '_mkl_service.c')]
if not exists(sources[0]):
raise ValueError(str(e) + '. ' +
'Cython is required to build the initial .c file.')
extensions = []
extensions.append(
setuptools.extension.Extension(
'mkl._mklinit',
sources=['mkl/_mklinitmodule.c'],
define_macros=defs,
include_dirs=mkl_include_dirs,
libraries=mkl_libraries,
library_dirs=mkl_library_dirs,
extra_compile_args=[
'-DNDEBUG'
# '-g', '-O2', '-Wall',
]
)
)
extensions.append(
setuptools.extension.Extension(
'mkl._py_mkl_service',
sources=sources,
include_dirs=mkl_include_dirs,
library_dirs=mkl_library_dirs,
libraries=mkl_libraries,
extra_compile_args=[
'-DNDEBUG'
# '-g', '-O2', '-Wall',
]
)
)
if have_cython:
extensions = cythonize(extensions, include_path=[join(__file__, pdir)])
return extensions
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info
config = Configuration('mkl_random', parent_package, top_path)
mkl_root = os.getenv('MKLROOT', None)
if mkl_root:
mkl_info = {
'include_dirs': [join(mkl_root, 'include')],
'library_dirs':
[join(mkl_root, 'lib'),
join(mkl_root, 'lib', 'intel64')],
'libraries': ['mkl_rt']
}
else:
mkl_info = get_info('mkl')
mkl_include_dirs = mkl_info.get('include_dirs', [])
mkl_library_dirs = mkl_info.get('library_dirs', [])
libs = mkl_info.get('libraries', ['mkl_rt'])
if sys.platform == 'win32':
libs.append('Advapi32')
Q = '/Q' if sys.platform.startswith(
'win') or sys.platform == 'cygwin' else '-'
pdir = 'mkl_random'
wdir = join(pdir, 'src')
eca = [Q + 'std=c++11']
if sys.platform == "linux":
eca.extend(["-Wno-unused-but-set-variable", "-Wno-unused-function"])
config.add_library(
'mkl_dists',
sources=join(wdir, 'mkl_distributions.cpp'),
libraries=libs,
include_dirs=[wdir, pdir,
get_numpy_include(),
get_python_include()],
extra_compiler_args=eca,
depends=[
join(wdir, '*.h'),
],
language='c++',
)
try:
from Cython.Build import cythonize
sources = [join(pdir, 'mklrand.pyx')]
have_cython = True
except ImportError as e:
have_cython = False
sources = [join(pdir, 'mklrand.c')]
if not exists(sources[0]):
raise ValueError(
str(e) + '. ' +
'Cython is required to build the initial .c file.')
# enable unix large file support on 32 bit systems
# (64 bit off_t, lseek -> lseek64 etc.)
defs = [('_FILE_OFFSET_BITS', '64'), ('_LARGEFILE_SOURCE', '1'),
('_LARGEFILE64_SOURCE', '1')]
if needs_mingw_ftime_workaround():
defs.append(("NEED_MINGW_TIME_WORKAROUND", None))
sources = sources + [join(wdir, x) for x in ['randomkit.c']]
libs = libs + ['mkl_dists']
config.add_extension(
name='mklrand',
sources=sources,
libraries=libs,
include_dirs=[wdir, pdir] + mkl_include_dirs,
library_dirs=mkl_library_dirs,
define_macros=defs,
)
config.add_data_files(('.', join('src', 'randomkit.h')))
config.add_data_files(('.', join('src', 'mkl_distributions.h')))
config.add_data_dir('tests')
if have_cython:
config.ext_modules = cythonize(config.ext_modules,
include_path=[pdir, wdir])
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_data_dir('tests')
config.add_data_dir('benchmarks')
return config
n, v = opt, True
n = n[2:] # remove --
default_options['install'][n] = v
# Find Fortran source code files
source_dirs, wrap_sources, wrap_types, quip_libraries, quip_targets = find_wrap_sources(
makefile, quip_root)
include_dirs.extend(source_dirs)
libraries = quip_libraries + libraries
# Add build.${QUIP_ARCH} to include and library paths
include_dirs.append(os.path.join(quip_root, 'build/%s' % quip_arch))
library_dirs.append(os.path.join(quip_root, 'build/%s' % quip_arch))
# arraydata extension module
f2py_info = get_info('f2py')
arraydata_ext = Extension(
name='quippy.arraydata',
sources=['arraydatamodule.c'] + f2py_info['sources'],
include_dirs=f2py_info['include_dirs'] + include_dirs,
define_macros=[('SIZEOF_FORTRAN_T', sizeof_fortran_t)],
extra_link_args=extra_link_args)
# _quippy extension module
quippy_ext = Extension(
name='quippy._quippy',
sources=[
F90WrapperBuilder(
'quippy',
wrap_sources=wrap_sources,
cpp=cpp,
BLAS = BLAS[0]
argv.remove(BLAS)
BLAS = BLAS.split('=')[1]
assert BLAS in ['openblas', 'mkl', 'atlas', 'blas']
libraries.append(BLAS)
blas_inc_dirs = os.environ.get('BLAS_INCLUDE_DIRS')
compile_args += [f'BLAS_INCLUDE_DIRS={blas_inc_dirs}']
blas_lib_dirs = os.environ.get('BLAS_LIBRARY_DIRS')
if blas_lib_dirs is not None:
extra_link_args += [f'-Wl,-rpath,{blas_lib_dirs}']
else:
# find the default BLAS library
import numpy.distutils.system_info as sysinfo
# Search blas in this order
for blas in ['openblas', 'atlas', 'mkl', 'blas']:
if 'libraries' in sysinfo.get_info(blas):
BLAS = blas
libraries += sysinfo.get_info(blas)['libraries']
break
else:
# BLAS not found
raise ImportError(' \
\nBLAS not found from numpy.distutils.system_info.get_info. \
\nPlease specify BLAS with: python setup.py install --blas=openblas" \
\nfor more information, please visit https://github.com/StanfordVL/MinkowskiEngine/wiki/Installation'
)
print(f'\nUsing BLAS={BLAS}')
compile_args += ['BLAS=' + BLAS]
# This script should run without errors whenever we update the
# kaggle/python container. It checks that all our most popular packages can
# be loaded and used without errors.
import numpy as np
print("Numpy imported ok")
print("Your lucky number is: " + str(np.random.randint(100)))
# Numpy must be linked to the MKL. (Occasionally, a third-party package will muck up the installation
# and numpy will be reinstalled with an OpenBLAS backing.)
from numpy.distutils.system_info import get_info
# This will throw an exception if the MKL is not linked correctly.
get_info("blas_mkl")
import pandas as pd
print("Pandas imported ok")
from sklearn import datasets
print("sklearn imported ok")
iris = datasets.load_iris()
X, y = iris.data, iris.target
from sklearn.ensemble import RandomForestClassifier
rf1 = RandomForestClassifier()
rf1.fit(X, y)
print("sklearn RandomForestClassifier: ok")
from sklearn.linear_model import LinearRegression
boston = datasets.load_boston()
X, y = boston.data, boston.target
lr1 = LinearRegression()
def run_compile():
"""
Do it all in one call!
"""
import tempfile
i = sys.argv.index('-c')
del sys.argv[i]
remove_build_dir = 0
try:
i = sys.argv.index('--build-dir')
except ValueError:
i = None
if i is not None:
build_dir = sys.argv[i + 1]
del sys.argv[i + 1]
del sys.argv[i]
else:
remove_build_dir = 1
build_dir = tempfile.mkdtemp()
_reg1 = re.compile(r'--link-')
sysinfo_flags = [_m for _m in sys.argv[1:] if _reg1.match(_m)]
sys.argv = [_m for _m in sys.argv if _m not in sysinfo_flags]
if sysinfo_flags:
sysinfo_flags = [f[7:] for f in sysinfo_flags]
_reg2 = re.compile(
r'--((no-|)(wrap-functions|lower)|debug-capi|quiet)|-include')
f2py_flags = [_m for _m in sys.argv[1:] if _reg2.match(_m)]
sys.argv = [_m for _m in sys.argv if _m not in f2py_flags]
f2py_flags2 = []
fl = 0
for a in sys.argv[1:]:
if a in ['only:', 'skip:']:
fl = 1
elif a == ':':
fl = 0
if fl or a == ':':
f2py_flags2.append(a)
if f2py_flags2 and f2py_flags2[-1] != ':':
f2py_flags2.append(':')
f2py_flags.extend(f2py_flags2)
sys.argv = [_m for _m in sys.argv if _m not in f2py_flags2]
_reg3 = re.compile(r'--((f(90)?compiler(-exec|)|compiler)=|help-compiler)')
flib_flags = [_m for _m in sys.argv[1:] if _reg3.match(_m)]
sys.argv = [_m for _m in sys.argv if _m not in flib_flags]
_reg4 = re.compile(
r'--((f(77|90)(flags|exec)|opt|arch)=|(debug|noopt|noarch|help-fcompiler))'
)
fc_flags = [_m for _m in sys.argv[1:] if _reg4.match(_m)]
sys.argv = [_m for _m in sys.argv if _m not in fc_flags]
del_list = []
for s in flib_flags:
v = '--fcompiler='
if s[:len(v)] == v:
from numpy.distutils import fcompiler
fcompiler.load_all_fcompiler_classes()
allowed_keys = list(fcompiler.fcompiler_class.keys())
nv = ov = s[len(v):].lower()
if ov not in allowed_keys:
vmap = {} # XXX
try:
nv = vmap[ov]
except KeyError:
if ov not in vmap.values():
print('Unknown vendor: "%s"' % (s[len(v):]))
nv = ov
i = flib_flags.index(s)
flib_flags[i] = '--fcompiler=' + nv
continue
for s in del_list:
i = flib_flags.index(s)
del flib_flags[i]
assert len(flib_flags) <= 2, repr(flib_flags)
_reg5 = re.compile(r'--(verbose)')
setup_flags = [_m for _m in sys.argv[1:] if _reg5.match(_m)]
sys.argv = [_m for _m in sys.argv if _m not in setup_flags]
if '--quiet' in f2py_flags:
setup_flags.append('--quiet')
modulename = 'untitled'
sources = sys.argv[1:]
for optname in ['--include_paths', '--include-paths', '--f2cmap']:
if optname in sys.argv:
i = sys.argv.index(optname)
f2py_flags.extend(sys.argv[i:i + 2])
del sys.argv[i + 1], sys.argv[i]
sources = sys.argv[1:]
if '-m' in sys.argv:
i = sys.argv.index('-m')
modulename = sys.argv[i + 1]
del sys.argv[i + 1], sys.argv[i]
sources = sys.argv[1:]
else:
from numpy.distutils.command.build_src import get_f2py_modulename
pyf_files, sources = filter_files('', '[.]pyf([.]src|)', sources)
sources = pyf_files + sources
for f in pyf_files:
modulename = get_f2py_modulename(f)
if modulename:
break
extra_objects, sources = filter_files('', '[.](o|a|so|dylib)', sources)
include_dirs, sources = filter_files('-I', '', sources, remove_prefix=1)
library_dirs, sources = filter_files('-L', '', sources, remove_prefix=1)
libraries, sources = filter_files('-l', '', sources, remove_prefix=1)
undef_macros, sources = filter_files('-U', '', sources, remove_prefix=1)
define_macros, sources = filter_files('-D', '', sources, remove_prefix=1)
for i in range(len(define_macros)):
name_value = define_macros[i].split('=', 1)
if len(name_value) == 1:
name_value.append(None)
if len(name_value) == 2:
define_macros[i] = tuple(name_value)
else:
print('Invalid use of -D:', name_value)
from numpy.distutils.system_info import get_info
num_info = {}
if num_info:
include_dirs.extend(num_info.get('include_dirs', []))
from numpy.distutils.core import setup, Extension
ext_args = {
'name': modulename,
'sources': sources,
'include_dirs': include_dirs,
'library_dirs': library_dirs,
'libraries': libraries,
'define_macros': define_macros,
'undef_macros': undef_macros,
'extra_objects': extra_objects,
'f2py_options': f2py_flags,
}
if sysinfo_flags:
from numpy.distutils.misc_util import dict_append
for n in sysinfo_flags:
i = get_info(n)
if not i:
outmess('No %s resources found in system'
' (try `f2py --help-link`)\n' % (repr(n)))
dict_append(ext_args, **i)
ext = Extension(**ext_args)
sys.argv = [sys.argv[0]] + setup_flags
sys.argv.extend([
'build',
'--build-temp',
build_dir,
'--build-base',
build_dir,
'--build-platlib',
'.',
# disable CCompilerOpt
'--disable-optimization'
])
if fc_flags:
sys.argv.extend(['config_fc'] + fc_flags)
if flib_flags:
sys.argv.extend(['build_ext'] + flib_flags)
setup(ext_modules=[ext])
if remove_build_dir and os.path.exists(build_dir):
import shutil
outmess('Removing build directory %s\n' % (build_dir))
shutil.rmtree(build_dir)
def build_ext(config):
# ==============================
# = Compile Fortran extensions =
# ==============================
from numpy.distutils.system_info import get_info
# If optimized lapack/ BLAS libraries are present, compile distributions that involve linear algebra against those.
# Otherwise compile blas and lapack from netlib sources.
lapack_info = get_info('lapack_opt', 1)
f_sources = [
'pymc/flib.f', 'pymc/histogram.f', 'pymc/flib_blas.f',
'pymc/blas_wrap.f', 'pymc/math.f', 'pymc/gibbsit.f', 'cephes/i0.c',
'cephes/c2f.c', 'cephes/chbevl.c'
]
if lapack_info:
config.add_extension(name='flib',
sources=f_sources,
extra_info=lapack_info,
f2py_options=['skip:ppnd7'])
if not lapack_info or dist in ['bdist', 'sdist']:
##inc_dirs = ['blas/BLAS','lapack/double']
print(
'No optimized BLAS or Lapack libraries found, building from source. This may take a while...'
)
for fname in os.listdir('blas/BLAS'):
# Make sure this is a Fortran file, and not one of those weird hidden files that
# pop up sometimes in the tarballs
if fname[-2:] == '.f' and fname[0].find('_') == -1:
f_sources.append('blas/BLAS/' + fname)
for fname in [
'dpotrs', 'dpotrf', 'dpotf2', 'ilaenv', 'dlamch', 'ilaver',
'ieeeck', 'iparmq'
]:
f_sources.append('lapack/double/' + fname + '.f')
config.add_extension(name='flib', sources=f_sources)
# ============================
# = Compile Pyrex extensions =
# ============================
config.add_extension(name='LazyFunction', sources=['pymc/LazyFunction.c'])
config.add_extension(name='Container_values',
sources='pymc/Container_values.c')
config_dict = config.todict()
try:
config_dict.pop('packages')
except:
pass
# ===========================================
# = Compile GP package's Fortran extensions =
# ===========================================
# Compile linear algebra utilities
if lapack_info:
config.add_extension(
name='gp.linalg_utils',
sources=['pymc/gp/linalg_utils.f', 'pymc/blas_wrap.f'],
extra_info=lapack_info)
config.add_extension(name='gp.incomplete_chol',
sources=['pymc/gp/incomplete_chol.f'],
extra_info=lapack_info)
if not lapack_info or dist in ['bdist', 'sdist']:
print(
'No optimized BLAS or Lapack libraries found, building from source. This may take a while...'
)
f_sources = ['pymc/blas_wrap.f']
for fname in os.listdir('blas/BLAS'):
if fname[-2:] == '.f':
f_sources.append('blas/BLAS/' + fname)
for fname in [
'dpotrs', 'dpotrf', 'dpotf2', 'ilaenv', 'dlamch', 'ilaver',
'ieeeck', 'iparmq'
]:
f_sources.append('lapack/double/' + fname + '.f')
config.add_extension(name='gp.linalg_utils',
sources=['pymc/gp/linalg_utils.f'] + f_sources)
config.add_extension(name='gp.incomplete_chol',
sources=['pymc/gp/incomplete_chol.f'] + f_sources)
# Compile covariance functions
config.add_extension(name='gp.cov_funs.isotropic_cov_funs',\
sources=['pymc/gp/cov_funs/isotropic_cov_funs.f','blas/BLAS/dscal.f'],\
extra_info=lapack_info)
config.add_extension(name='gp.cov_funs.distances',
sources=['pymc/gp/cov_funs/distances.f'],
extra_info=lapack_info)
return config_dict
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
from numpy.distutils.system_info import get_info
config = Configuration('suitesparse', parent_package, top_path)
# SuiteSparse_config
ss_config_opts = {
'name':
'suitesparseconfig',
'sources': [
str((SS / 'SuiteSparse_config/SuiteSparse_config.c').relative_to(
SS.parent))
],
'include_dirs':
[str((SS / 'SuiteSparse_config').relative_to(SS.parent))],
'language':
'c',
}
config.add_library(**ss_config_opts)
config.add_extension(**ss_config_opts,
extra_info={
'sources': ['suitesparseconfig_impl.c'],
'libraries': ['suitesparseconfig'],
})
# AMD
if not (tmp / 'AMDI/Include').exists():
(tmp / 'AMDI/Include').mkdir(exist_ok=True, parents=True)
(tmp / 'AMDL/Include').mkdir(exist_ok=True, parents=True)
shutil.copyfile(SS / 'AMD/Include/amd_internal.h',
tmp / 'AMDI/Include/amd_i_internal.h')
shutil.copyfile(SS / 'AMD/Include/amd_internal.h',
tmp / 'AMDL/Include/amd_l_internal.h')
_add_macros(f=(tmp / 'AMDI/Include/amd_i_internal.h'), macros=['DINT'])
_add_macros(f=(tmp / 'AMDL/Include/amd_l_internal.h'),
macros=['DLONG'])
if not (tmp / 'AMDI/Source').exists():
shutil.copytree(SS / 'AMD/Source', tmp / 'AMDI/Source')
shutil.copytree(SS / 'AMD/Source', tmp / 'AMDL/Source')
for type_ in (('DINT', 'i', 'I'), ('DLONG', 'l', 'L')):
for f in (tmp / f'AMD{type_[2]}/Source').glob('amd_*.c'):
fnew = f.parent / f.name.replace('amd_', f'amd_{type_[1]}_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=[type_[0]])
_redirect_headers(f=fnew,
headers=[('amd_internal.h',
f'amd_{type_[1]}_internal.h')])
amd_opts = {
'name':
'amd',
'sources': ([
str(f.relative_to(SS.parent))
for f in (tmp / 'AMDI/Source').glob('amd_*.c')
] + [
str(f.relative_to(SS.parent))
for f in (tmp / 'AMDL/Source').glob('amd_*.c')
]),
'include_dirs': [
str((SS / 'SuiteSparse_config').relative_to(SS.parent)),
str((SS / 'AMD/Include').relative_to(SS.parent)),
str((tmp / 'AMDI/Include').relative_to(SS.parent)),
str((tmp / 'AMDL/Include').relative_to(SS.parent)),
],
'libraries': ['suitesparseconfig'],
'language':
'c',
}
config.add_library(**amd_opts)
config.add_extension(**amd_opts,
extra_info={
'sources': ['amd_impl.c'],
'export_symbols': [
'amd_order',
'amd_l_order',
'amd_2',
'amd_l2',
'amd_valid',
'amd_l_valid',
'amd_defaults',
'amd_l_defaults',
'amd_control',
'amd_l_control',
'amd_info',
'amd_l_info',
],
'libraries': ['amd'],
})
# CAMD
if not (tmp / 'CAMDI/Include').exists():
(tmp / 'CAMDI/Include').mkdir(exist_ok=True, parents=True)
(tmp / 'CAMDL/Include').mkdir(exist_ok=True, parents=True)
shutil.copyfile(SS / 'CAMD/Include/camd_internal.h',
tmp / 'CAMDI/Include/camd_i_internal.h')
shutil.copyfile(SS / 'CAMD/Include/camd_internal.h',
tmp / 'CAMDL/Include/camd_l_internal.h')
_add_macros(f=(tmp / f'CAMDI/Include/camd_i_internal.h'),
macros=['DINT'])
_add_macros(f=(tmp / f'CAMDL/Include/camd_l_internal.h'),
macros=['DLONG'])
if not (tmp / 'CAMDI/Source').exists():
shutil.copytree(SS / 'CAMD/Source', tmp / 'CAMDI/Source')
shutil.copytree(SS / 'CAMD/Source', tmp / 'CAMDL/Source')
for type_ in (('DINT', 'i', 'I'), ('DLONG', 'l', 'L')):
for f in (tmp / f'CAMD{type_[2]}/Source').glob('camd_*.c'):
fnew = f.parent / f.name.replace('camd_', f'camd_{type_[1]}_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=[type_[0]])
_redirect_headers(f=fnew,
headers=[('camd_internal.h',
f'camd_{type_[1]}_internal.h')])
camd_opts = {
'name':
'camd',
'sources': ([
str(f.relative_to(SS.parent))
for f in (tmp / 'CAMDI/Source').glob('camd_*.c')
] + [
str(f.relative_to(SS.parent))
for f in (tmp / 'CAMDL/Source').glob('camd_*.c')
]),
'include_dirs': [
str((SS / 'SuiteSparse_config').relative_to(SS.parent)),
str((SS / 'CAMD/Include').relative_to(SS.parent)),
str((tmp / 'CAMDI/Include').relative_to(SS.parent)),
str((tmp / 'CAMDL/Include').relative_to(SS.parent)),
],
'libraries': ['suitesparseconfig'],
'language':
'c',
}
config.add_library(**camd_opts)
config.add_extension(**camd_opts,
extra_info={
'sources': ['camd_impl.c'],
'export_symbols': [
'camd_order',
'camd_l_order',
'camd_2',
'camd_l2',
'camd_valid',
'camd_l_valid',
'camd_cvalid',
'camd_l_cvalid',
'camd_defaults',
'camd_l_defaults',
'camd_control',
'camd_l_control',
'camd_info',
'camd_l_info',
],
'libraries': ['camd'],
})
# COLAMD
if not (tmp / 'COLAMDI/Source').exists():
shutil.copytree(SS / 'COLAMD/Source', tmp / 'COLAMDI/Source')
shutil.copytree(SS / 'COLAMD/Source', tmp / 'COLAMDL/Source')
for type_ in (('', '', 'I'), ('DLONG', '_l', 'L')):
f = (tmp / f'COLAMD{type_[2]}/Source/colamd.c')
fnew = f.parent / f'colamd{type_[1]}.c'
shutil.move(f, fnew)
_add_macros(f=fnew, macros=[type_[0]])
colamd_opts = {
'name':
'colamd',
'sources': [
str((tmp / 'COLAMDI/Source/colamd.c').relative_to(SS.parent)),
str((tmp / 'COLAMDL/Source/colamd_l.c').relative_to(SS.parent)),
],
'include_dirs': [
str((SS / 'SuiteSparse_config').relative_to(SS.parent)),
str((SS / 'COLAMD/Include').relative_to(SS.parent)),
],
'libraries': ['suitesparseconfig'],
'language':
'c',
}
config.add_library(**colamd_opts)
config.add_extension(**colamd_opts,
extra_info={
'sources': ['colamd_impl.c'],
'libraries': ['colamd'],
'export_symbols': [
'colamd_recommended',
'colamd_l_recommended',
'colamd_set_defaults',
'colamd_l_set_defaults',
'colamd',
'colamd_l',
'symamd',
'symamd_l',
'colamd_report',
'colamd_l_report',
'symamd_report',
'symamd_l_report',
],
})
# CCOLAMD
if not (tmp / 'CCOLAMDI/Source').exists():
shutil.copytree(SS / 'CCOLAMD/Source', tmp / 'CCOLAMDI/Source')
shutil.copytree(SS / 'CCOLAMD/Source', tmp / 'CCOLAMDL/Source')
for type_ in (('', '', 'I'), ('DLONG', '_l', 'L')):
f = (tmp / f'CCOLAMD{type_[2]}/Source/ccolamd.c')
fnew = f.parent / f'ccolamd{type_[1]}.c'
shutil.move(f, fnew)
_add_macros(f=fnew, macros=[type_[0]])
ccolamd_opts = {
'name':
'ccolamd',
'sources': [
str((tmp / 'CCOLAMDI/Source/ccolamd.c').relative_to(SS.parent)),
str((tmp / 'CCOLAMDL/Source/ccolamd_l.c').relative_to(SS.parent)),
],
'include_dirs': [
str((SS / 'SuiteSparse_config').relative_to(SS.parent)),
str((SS / 'CCOLAMD/Include').relative_to(SS.parent)),
],
'libraries': ['suitesparseconfig'],
'language':
'c',
}
config.add_library(**ccolamd_opts)
config.add_extension(**ccolamd_opts,
extra_info={
'sources': ['ccolamd_impl.c'],
'libraries': ['ccolamd'],
'export_symbols': [
'ccolamd_recommended',
'ccolamd_l_recommended',
'ccolamd_set_defaults',
'ccolamd_l_set_defaults',
'ccolamd',
'ccolamd_l',
'csymamd',
'csymamd_l',
'ccolamd_report',
'ccolamd_l_report',
'csymamd_report',
'csymamd_l_report',
'ccolamd2',
'ccolamd2_l',
'ccolamd_apply_order',
'ccolamd_l_apply_order',
'ccolamd_fsize',
'ccolamd_l_fsize',
'ccolamd_postorder',
'ccolamd_l_postorder',
'ccolamd_post_tree',
'ccolamd_l_post_tree',
],
})
# CHOLMOD/Check module
cholmod_sources = [
str((SS / 'CHOLMOD/Check/cholmod_check.c').relative_to(SS.parent)),
str((SS / 'CHOLMOD/Check/cholmod_read.c').relative_to(SS.parent)),
str((SS / 'CHOLMOD/Check/cholmod_write.c').relative_to(SS.parent)),
str((tmp / 'CHOLMODL/Check/cholmod_l_check.c').relative_to(SS.parent)),
str((tmp / 'CHOLMODL/Check/cholmod_l_read.c').relative_to(SS.parent)),
str((tmp / 'CHOLMODL/Check/cholmod_l_write.c').relative_to(SS.parent))
]
cholmod_includes = [
str((SS / 'AMD/Include').relative_to(SS.parent)),
str((SS / 'AMD/Source').relative_to(SS.parent)),
str((SS / 'COLAMD/Include').relative_to(SS.parent)),
str((SS / 'CHOLMOD/Include').relative_to(SS.parent)),
str((tmp / 'CHOLMODL/Include').relative_to(SS.parent))
]
cholmod_l_hdrs = [(hdr.name, hdr.name.replace('cholmod', 'cholmod_l'))
for hdr in (SS / 'CHOLMOD/Include').glob('*.h')]
if not (tmp / 'CHOLMODL/Include').exists():
shutil.copytree(SS / 'CHOLMOD/Include', tmp / 'CHOLMODL/Include')
for f in (tmp / 'CHOLMODL/Include').glob('*.h'):
fnew = f.parent / f.name.replace('cholmod', 'cholmod_l')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(f=fnew, headers=cholmod_l_hdrs)
if not (tmp / 'CHOLMODL/Check').exists():
shutil.copytree(SS / 'CHOLMOD/Check', tmp / 'CHOLMODL/Check')
for f in (tmp / 'CHOLMODL/Check').glob('cholmod_*.c'):
fnew = f.parent / f.name.replace('cholmod_', 'cholmod_l_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(
f=fnew,
headers=[('cholmod_internal.h', 'cholmod_l_internal.h'),
('cholmod_check.h', 'cholmod_l_check.h'),
('cholmod_config.h', 'cholmod_l_config.h'),
('cholmod_matrixops.h', 'cholmod_l_matrixops.h')])
# CHOLMOD/Core module
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (SS / 'CHOLMOD/Core').glob('cholmod_*.c')
]
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (tmp / 'CHOLMODL/Core').glob('cholmod_*.c')
]
if not (tmp / 'CHOLMODL/Core').exists():
shutil.copytree(SS / 'CHOLMOD/Core', tmp / 'CHOLMODL/Core')
for f in (tmp / 'CHOLMODL/Core').glob('*.c'):
fnew = f.parent / f.name.replace('cholmod_', 'cholmod_l_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(
f=fnew,
headers=cholmod_l_hdrs +
[('t_cholmod_change_factor.c', 't_cholmod_l_change_factor.c'),
('t_cholmod_dense.c', 't_cholmod_l_dense.c'),
('t_cholmod_transpose.c', 't_cholmod_l_transpose.c'),
('t_cholmod_triplet.c', 't_cholmod_l_triplet.c')])
# CHOLMOD/Cholesky module
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (SS / 'CHOLMOD/Cholesky').glob('cholmod_*.c')
]
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (tmp / 'CHOLMODL/Cholesky').glob('cholmod_*.c')
]
if not (tmp / 'CHOLMODL/Cholesky').exists():
shutil.copytree(SS / 'CHOLMOD/Cholesky', tmp / 'CHOLMODL/Cholesky')
for f in (tmp / 'CHOLMODL/Cholesky').glob('*.c'):
fnew = f.parent / f.name.replace('cholmod_', 'cholmod_l_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(
f=fnew,
headers=cholmod_l_hdrs +
[('t_cholmod_lsolve.c', 't_cholmod_l_lsolve.c'),
('t_cholmod_ltsolve.c', 't_cholmod_l_ltsolve.c'),
('t_cholmod_rowfac.c', 't_cholmod_l_rowfac.c'),
('t_cholmod_solve.c', 't_cholmod_l_solve.c'),
('t_cholmod_dense.c', 't_cholmod_l_dense.c')])
# CHOLMOD/Partition module
cholmod_includes += [
str((SS / 'metis-5.1.0/include').relative_to(SS.parent)),
str((SS / 'CAMD/Include').relative_to(SS.parent)),
str((SS / 'CCOLAMD/Include').relative_to(SS.parent)),
]
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (SS / 'CHOLMOD/Partition').glob('cholmod_*.c')
]
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (tmp / 'CHOLMODL/Partition').glob('cholmod_l_*.c')
]
if not (tmp / 'CHOLMODL/Parititon').exists():
shutil.copytree(SS / 'CHOLMOD/Partition', tmp / 'CHOLMODL/Parititon')
for f in (tmp / 'CHOLMODL/Parititon').glob('*.c'):
fnew = f.parent / f.name.replace('cholmod_', 'cholmod_l_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(f=fnew, headers=cholmod_l_hdrs)
# CHOLMOD/MatrixOps module
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (SS / 'CHOLMOD/MatrixOps').glob('cholmod_*.c')
]
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (tmp / 'CHOLMODL/MatrixOps').glob('cholmod_l_*.c')
]
if not (tmp / 'CHOLMODL/MatrixOps').exists():
shutil.copytree(SS / 'CHOLMOD/MatrixOps', tmp / 'CHOLMODL/MatrixOps')
for f in (tmp / 'CHOLMODL/MatrixOps').glob('*.c'):
fnew = f.parent / f.name.replace('cholmod_', 'cholmod_l_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(f=fnew,
headers=cholmod_l_hdrs +
[('t_cholmod_sdmult.c', 't_cholmod_l_sdmult.c')])
# CHOLMOD/Modify module
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (SS / 'CHOLMOD/Modify').glob('cholmod_*.c')
]
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (tmp / 'CHOLMODL/Modify').glob('cholmod_l_*.c')
]
if not (tmp / 'CHOLMODL/Modify').exists():
shutil.copytree(SS / 'CHOLMOD/Modify', tmp / 'CHOLMODL/Modify')
for f in (tmp / 'CHOLMODL/Modify').glob('*.c'):
fnew = f.parent / f.name.replace('cholmod_', 'cholmod_l_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(
f=fnew,
headers=cholmod_l_hdrs +
[('t_cholmod_updown.c', 't_cholmod_l_updown.c'),
('t_cholmod_updown_numkr.c', 't_cholmod_l_updown_numkr.c')])
# CHOLMOD/Supernodal module
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (SS / 'CHOLMOD/Supernodal').glob('cholmod_*.c')
]
cholmod_sources += [
str(f.relative_to(SS.parent))
for f in (tmp / 'CHOLMODL/Supernodal').glob('cholmod_l_*.c')
]
if not (tmp / 'CHOLMODL/Supernodal').exists():
shutil.copytree(SS / 'CHOLMOD/Supernodal', tmp / 'CHOLMODL/Supernodal')
for f in (tmp / 'CHOLMODL/Supernodal').glob('*.c'):
fnew = f.parent / f.name.replace('cholmod_', 'cholmod_l_')
shutil.move(f, fnew)
_add_macros(f=fnew, macros=['DLONG'])
_redirect_headers(
f=fnew,
headers=cholmod_l_hdrs +
[('t_cholmod_super_numeric.c', 't_cholmod_l_super_numeric.c'),
('t_cholmod_super_solve.c', 't_cholmod_l_super_solve.c')])
# CHOLMOD
#lapack_info = get_info('lapack')
cholmod_opts = {
'name':
'cholmod',
'sources':
cholmod_sources,
'include_dirs':
[str((SS / 'SuiteSparse_config').relative_to(SS.parent))] +
cholmod_includes,
'libraries': ['amd', 'colamd', 'suitesparseconfig'],
'language':
'c',
}
config.add_library(**cholmod_opts, macros=[('NPARTITION', None)])
config.add_extension(**cholmod_opts,
extra_info={
'sources': ['cholmod_impl.c'],
'libraries': ['cholmod', 'openblas'],
'define_macros': [('NPARTITION', None)],
'export_symbols': [],
})
return config
# SPQR
config.add_library(
'spqr',
sources=[
str(f.relative_to(SS.parent))
for f in (SS / 'SPQR/Source').glob('*.cpp')
],
include_dirs=[
str((SS / 'SPQR/Include').relative_to(SS.parent)),
str((SS / 'CHOLMOD/Include').relative_to(SS.parent)),
str((SS / 'SuiteSparse_config').relative_to(SS.parent)),
],
libraries=['amd', 'colamd', 'cholmod', 'suitesparseconfig'],
language='c')
shutil.copytree(SS / 'UMFPACK/Source', tmp / 'UMFPACKI/Source')
shutil.copytree(SS / 'UMFPACK/Source', tmp / 'UMFPACKL/Source')
shutil.copytree(SS / 'UMFPACK/Source', tmp / 'UMFPACKDI/Source')
shutil.copytree(SS / 'UMFPACK/Source', tmp / 'UMFPACKDL/Source')
shutil.copytree(SS / 'UMFPACK/Source', tmp / 'UMFPACKZI/Source')
shutil.copytree(SS / 'UMFPACK/Source', tmp / 'UMFPACKZL/Source')
umf_hdrs = {}
for type_, macros in [('i', ['DINT']), ('l', ['DLONG']), ('di', ['DINT']),
('dl', ['DLONG']), ('zi', ['ZINT']),
('zl', ['ZLONG'])]:
umf_hdrs[type_] = (
[(f.name, f.name.replace('umf_', f'umf_{type_}_'))
for f in (SS / 'UMFPACK/Source').glob('umf_*.h')] +
[(f.name, f.name.replace('umfpack_', f'umfpack_{type_}_'))
for f in (SS / 'UMFPACK/Source').glob('umfpack_*.h')] +
[('amd_internal.h',
f'amd_{type_[-1] if type_ != "zl" else type_}_internal.h')])
for f in (tmp / f'UMFPACK{type_.upper()}/Source/').glob('umf_*.h'):
fnew = f.parent / f.name.replace('umf_', f'umf_{type_}_')
shutil.move(f, fnew.relative_to(SS.parent))
_add_macros(f=fnew, macros=macros)
_redirect_headers(f=fnew, headers=umf_hdrs[type_])
# non-user-callable umf_*.[ch] files, int/SuiteSparse_long versions only
# (no real/complex):
UMFINT = [
'umf_analyze', 'umf_apply_order', 'umf_colamd', 'umf_free',
'umf_fsize', 'umf_is_permutation', 'umf_malloc', 'umf_realloc',
'umf_report_perm', 'umf_singletons', 'umf_cholmod'
]
umfpack_sources = []
for type_, macro in [('i', 'DINT'), ('l', 'DLONG')]:
for f0 in UMFINT:
f = tmp / f'UMFPACK{type_.upper()}/Source/{f0}.c'
fnew = f.parent / f.name.replace('umf_', f'umf_{type_}_')
umfpack_sources.append(str(fnew.relative_to(SS.parent)))
shutil.move(f, fnew)
_add_macros(f=fnew, macros=[macro])
_redirect_headers(f=fnew, headers=umf_hdrs[type_])
# non-user-callable, created from umf_ltsolve.c, umf_utsolve.c,
# umf_triplet.c, and umf_assemble.c , with int/SuiteSparse_long
# and real/complex versions:
UMF_CREATED = [
'umf_lhsolve', 'umf_uhsolve', 'umf_triplet_map_nox',
'umf_triplet_nomap_x', 'umf_triplet_nomap_nox', 'umf_triplet_map_x',
'umf_assemble_fixq', 'umf_store_lu_drop'
]
# non-user-callable umf_*.[ch] files:
UMFCH = [
'umf_assemble', 'umf_blas3_update', 'umf_build_tuples',
'umf_create_element', 'umf_dump', 'umf_extend_front',
'umf_garbage_collection', 'umf_get_memory', 'umf_init_front',
'umf_kernel', 'umf_kernel_init', 'umf_kernel_wrapup',
'umf_local_search', 'umf_lsolve', 'umf_ltsolve',
'umf_mem_alloc_element', 'umf_mem_alloc_head_block',
'umf_mem_alloc_tail_block', 'umf_mem_free_tail_block',
'umf_mem_init_memoryspace', 'umf_report_vector', 'umf_row_search',
'umf_scale_column', 'umf_set_stats', 'umf_solve', 'umf_symbolic_usage',
'umf_transpose', 'umf_tuple_lengths', 'umf_usolve', 'umf_utsolve',
'umf_valid_numeric', 'umf_valid_symbolic', 'umf_grow_front',
'umf_start_front', 'umf_store_lu', 'umf_scale'
]
# non-user-callable, int/SuiteSparse_long and real/complex versions:
UMF = UMF_CREATED + UMFCH
# user-callable umfpack_*.[ch] files (int/SuiteSparse_long and real/complex):
UMFPACK = [
'umfpack_col_to_triplet', 'umfpack_defaults', 'umfpack_free_numeric',
'umfpack_free_symbolic', 'umfpack_get_numeric', 'umfpack_get_lunz',
'umfpack_get_symbolic', 'umfpack_get_determinant', 'umfpack_numeric',
'umfpack_qsymbolic', 'umfpack_report_control', 'umfpack_report_info',
'umfpack_report_matrix', 'umfpack_report_numeric',
'umfpack_report_perm', 'umfpack_report_status',
'umfpack_report_symbolic', 'umfpack_report_triplet',
'umfpack_report_vector', 'umfpack_solve', 'umfpack_symbolic',
'umfpack_transpose', 'umfpack_triplet_to_col', 'umfpack_scale',
'umfpack_load_numeric', 'umfpack_save_numeric',
'umfpack_load_symbolic', 'umfpack_save_symbolic'
]
# user-callable, created from umfpack_solve.c (umfpack_wsolve.h exists, though):
# with int/SuiteSparse_long and real/complex versions:
UMFPACKW = ['umfpack_wsolve']
UMFUSER = UMFPACKW + UMFPACK
_special_macros = {
r'umf_[dz][il]_\whsolve': ['CONJUGATE_SOLVE'],
r'umf_[dz][il]_triplet_map_x': ['DO_MAP', 'DO_VALUES'],
r'umf_[dz][il]_triplet_map_nox': ['DO_MAP'],
r'umf_[dz][il]_triplet_nomap_x': ['DO_VALUES'],
r'umf_[dz][il]_assemble_fixq': ['FIXQ'],
r'umf_[dz][il]_store_lu_drop': ['DROP'],
r'umfpack_[dz][il]_wsolve': ['WSOLVE'],
}
do_copy = False
for type_, macro in [('di', ['DINT']), ('dl', ['DLONG']), ('zi', ['ZINT']),
('zl', ['ZLONG'])]:
for f0 in UMF + UMFUSER: # TODO: UMFUSER targets not building!
f = tmp / f'UMFPACK{type_.upper()}/Source/{f0}.c'
if f0.startswith('umf_'):
fnew = f.parent / f.name.replace('umf_', f'umf_{type_}_')
else:
fnew = f.parent / f.name.replace('umfpack_',
f'umfpack_{type_}_')
# convert targets to correct source files names:
if 'hsolve' in fnew.name:
f = f.parent / f.name.replace('hsolve', 'tsolve')
elif 'umf_triplet' in f0:
f = f.parent / 'umf_triplet.c'
do_copy = True
elif 'assemble' in fnew.name:
f = f.parent / 'umf_assemble.c'
do_copy = True
elif 'store_lu' in fnew.name:
f = f.parent / 'umf_store_lu.c'
do_copy = True
elif 'wsolve':
f = f.parent / 'umfpack_solve.c'
do_copy = True
umfpack_sources.append(str(fnew.relative_to(SS.parent)))
if not do_copy:
shutil.move(f, fnew)
else:
shutil.copyfile(f, fnew)
do_copy = False
# Do any extra macros apply to this file?
extra_macros = []
for regex in _special_macros:
match = re.search(regex, fnew.name)
if match:
extra_macros += _special_macros[regex]
break
_add_macros(f=fnew, macros=macro + extra_macros)
_redirect_headers(f=fnew, headers=umf_hdrs[type_])
# user-callable, only one version for int/SuiteSparse_long,
# real/complex, *.[ch] files:
GENERIC = ['umfpack_timer', 'umfpack_tictoc']
for f0 in GENERIC:
f = SS / f'UMFPACK/Source/{f0}.c'
umfpack_sources.append(str(f.relative_to(SS.parent)))
# UMFPACK
config.add_library(
'umfpack',
sources=umfpack_sources,
include_dirs=[
str((tmp / 'UMFPACKI/Source').relative_to(SS.parent)),
str((tmp / 'UMFPACKL/Source').relative_to(SS.parent)),
str((tmp / 'UMFPACKDI/Source').relative_to(SS.parent)),
str((tmp / 'UMFPACKDL/Source').relative_to(SS.parent)),
str((tmp / 'UMFPACKZI/Source').relative_to(SS.parent)),
str((tmp / 'UMFPACKZL/Source').relative_to(SS.parent)),
str((tmp / 'AMDI/Include').relative_to(SS.parent)),
str((tmp / 'AMDL/Include').relative_to(SS.parent)),
str((tmp / 'AMDZL/Include').relative_to(SS.parent)),
str((SS / 'UMFPACK/Include').relative_to(SS.parent)),
str((SS / 'UMFPACK/Source').relative_to(SS.parent)),
str((SS / 'AMD/Include').relative_to(SS.parent)),
str((SS / 'SuiteSparse_config').relative_to(SS.parent)),
str((SS / 'CHOLMOD/Include').relative_to(SS.parent)),
],
libraries=['amd', 'cholmod', 'suitesparseconfig'],
language='c')
# UMFPACK test
lapack_opt = get_info('lapack')
config.add_extension(
'umfpack_demo',
sources=['umfpack_demo.c'],
include_dirs=[
str((SS / 'SuiteSparse_config').relative_to(SS.parent)),
str((SS / 'AMD/Include').relative_to(SS.parent)),
str((SS / 'UMFPACK/Include').relative_to(SS.parent)),
],
libraries=['umfpack'],
language='c',
extra_info=lapack_opt,
)
return config
def configuration(parent_package='', top_path=None):
from distutils.sysconfig import get_python_inc
from numpy.distutils.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_sgemv_fix, get_g77_abi_wrappers,
split_fortran_files)
config = Configuration('linalg', parent_package, top_path)
lapack_opt = get_info('lapack_opt')
if not lapack_opt:
raise NotFoundError('no lapack/blas resources found')
atlas_version = ([v[3:-3] for k, v in lapack_opt.get('define_macros', [])
if k == 'ATLAS_INFO']+[None])[0]
if atlas_version:
print(('ATLAS version: %s' % atlas_version))
# fblas:
sources = ['fblas.pyf.src']
sources += get_g77_abi_wrappers(lapack_opt)
sources += get_sgemv_fix(lapack_opt)
config.add_extension('_fblas',
sources=sources,
depends=['fblas_l?.pyf.src'],
extra_info=lapack_opt
)
# flapack:
sources = ['flapack.pyf.src']
sources += get_g77_abi_wrappers(lapack_opt)
dep_pfx = join('src', 'lapack_deprecations')
deprecated_lapack_routines = [join(dep_pfx, c + 'gegv.f') for c in 'cdsz']
sources += deprecated_lapack_routines
config.add_extension('_flapack',
sources=sources,
depends=['flapack_user.pyf.src'],
extra_info=lapack_opt
)
if atlas_version is not None:
# cblas:
config.add_extension('_cblas',
sources=['cblas.pyf.src'],
depends=['cblas.pyf.src', 'cblas_l1.pyf.src'],
extra_info=lapack_opt
)
# clapack:
config.add_extension('_clapack',
sources=['clapack.pyf.src'],
depends=['clapack.pyf.src'],
extra_info=lapack_opt
)
# _flinalg:
config.add_extension('_flinalg',
sources=[join('src', 'det.f'), join('src', 'lu.f')],
extra_info=lapack_opt
)
# _interpolative:
routines_to_split = [
'dfftb1',
'dfftf1',
'dffti1',
'dsint1',
'dzfft1',
'id_srand',
'idd_copyints',
'idd_id2svd0',
'idd_pairsamps',
'idd_permute',
'idd_permuter',
'idd_random_transf0',
'idd_random_transf0_inv',
'idd_random_transf_init0',
'idd_subselect',
'iddp_asvd0',
'iddp_rsvd0',
'iddr_asvd0',
'iddr_rsvd0',
'idz_estrank0',
'idz_id2svd0',
'idz_permute',
'idz_permuter',
'idz_random_transf0_inv',
'idz_random_transf_init0',
'idz_random_transf_init00',
'idz_realcomp',
'idz_realcomplex',
'idz_reco',
'idz_subselect',
'idzp_aid0',
'idzp_aid1',
'idzp_asvd0',
'idzp_rsvd0',
'idzr_asvd0',
'idzr_reco',
'idzr_rsvd0',
'zfftb1',
'zfftf1',
'zffti1',
]
print('Splitting linalg.interpolative Fortran source files')
dirname = os.path.split(os.path.abspath(__file__))[0]
fnames = split_fortran_files(join(dirname, 'src', 'id_dist', 'src'),
routines_to_split)
fnames = [join('src', 'id_dist', 'src', f) for f in fnames]
config.add_extension('_interpolative', fnames + ["interpolative.pyf"],
extra_info=lapack_opt
)
# _solve_toeplitz:
config.add_extension('_solve_toeplitz',
sources=[('_solve_toeplitz.c')],
include_dirs=[get_numpy_include_dirs()])
config.add_data_dir('tests')
# Cython BLAS/LAPACK
config.add_data_files('cython_blas.pxd')
config.add_data_files('cython_lapack.pxd')
sources = ['_blas_subroutine_wrappers.f', '_lapack_subroutine_wrappers.f']
sources += get_g77_abi_wrappers(lapack_opt)
sources += get_sgemv_fix(lapack_opt)
includes = numpy_info().get_include_dirs() + [get_python_inc()]
config.add_library('fwrappers', sources=sources, include_dirs=includes)
config.add_extension('cython_blas',
sources=['cython_blas.c'],
depends=['cython_blas.pyx', 'cython_blas.pxd',
'fortran_defs.h', '_blas_subroutines.h'],
include_dirs=['.'],
libraries=['fwrappers'],
extra_info=lapack_opt)
config.add_extension('cython_lapack',
sources=['cython_lapack.c'],
depends=['cython_lapack.pyx', 'cython_lapack.pxd',
'fortran_defs.h', '_lapack_subroutines.h'],
include_dirs=['.'],
libraries=['fwrappers'],
extra_info=lapack_opt)
config.add_extension('_decomp_update',
sources=['_decomp_update.c'])
# Add any license files
config.add_data_files('src/id_dist/doc/doc.tex')
config.add_data_files('src/lapack_deprecations/LICENSE')
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)))
check_math_capabilities(config_cmd, moredefs, mathlibs)
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]))
# Keep those for backward compatibility for now
target_f.write("""
#ifdef HAVE_EXPL
#define HAVE_LONGDOUBLE_FUNCS
#endif
#ifdef HAVE_EXPF
#define HAVE_FLOAT_FUNCS
#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.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."
moredefs = []
# Check wether we can use inttypes (C99) formats
if config_cmd.check_decl('PRIdPTR', headers=['inttypes.h']):
moredefs.append(('NPY_USE_C99_FORMATS', 1))
else:
moredefs.append(('NPY_USE_C99_FORMATS', 0))
# Add moredefs to header
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]))
# 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')
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', '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_numpy_api,
join('src', 'scalartypes.inc.src'),
join('src', 'arraytypes.inc.src'),
join(codegen_dir, 'generate_numpy_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'),
join('src', 'umath_funcs_c99.inc.src'),
join('src', 'umath_funcs.inc.src'),
join('src', 'umath_loops.inc.src'),
],
depends=[
join('src', 'umath_ufunc_object.inc'),
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_numpy_api,
],
)
config.add_extension(
'scalarmath',
sources=[
join('src', 'scalarmathmodule.c.src'), generate_config_h,
generate_numpyconfig_h, generate_numpy_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_extension('umath_tests',
# sources = [join('src','umath_tests.c.src'),
# ],
# depends = [join('blasdot','cblas.h'),] + deps,
# 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