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 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 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 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 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):
    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):
    
    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 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 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

    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 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 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='',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):
    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.misc_util import Configuration, get_mathlibs
    config = Configuration('random',parent_package,top_path)

    def generate_libraries(ext, build_dir):
        config_cmd = config.get_config_cmd()
        libs = get_mathlibs()
        tc = testcode_wincrypt()
        if config_cmd.try_run(tc):
            libs.append('Advapi32')
        ext.libraries.extend(libs)
        return None

    # Configure mtrand
    config.add_extension('mtrand',
                         sources=[join('mtrand', x) for x in
                                  ['mtrand.c', 'randomkit.c', 'initarray.c',
                                   'distributions.c']
                                  ] + [generate_libraries],
                         depends = [join('mtrand','*.h'),
                                    join('mtrand','*.pyx'),
                                    join('mtrand','*.pxi'),
                                    ],
                         **get_info('ndarray'))

    config.add_data_files(('.', join('mtrand', 'randomkit.h')))
    config.add_data_dir('tests')

    return config

def configuration (parent_package=''):
    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