cmake_minimum_required(VERSION3.11.0)

project(arrayfire-python)

find_package(PythonExtensionsREQUIRED)

include(FetchContent)

set(CMAKE_MODULE_PATH_OLD${CMAKE_MODULE_PATH})

set(CMAKE_MODULE_PATH"")

set(NO_SONAME)

FetchContent_Declare(

)

FetchContent_MakeAvailable(arrayfire)

set(CMAKE_MODULE_PATH${CMAKE_MODULE_PATH_OLD})

set(ignoreWarning"${SKBUILD}")

Choosing a particular backend can be done using`af.set_backend(name)` where name is either "_cuda_", "_opencl_", or "_cpu_". The default device is chosen in the same order of preference.

Currently, this project is tested only on Linux and OSX.Youalso need to havethe ArrayFire C/C++ libraryinstalled on your machine. You can get itfrom the following sources.

Youcan getthe ArrayFire C/C++ library from the following sources:

-[Download and install binaries](https://arrayfire.com/download)

-[Build and install from source](https://github.com/arrayfire/arrayfire)

Please check the following links for dependencies.

-[Linux dependencies](http://www.arrayfire.com/docs/using_on_linux.htm)

-[OSX dependencies](http://www.arrayfire.com/docs/using_on_osx.htm)

**Install the last stable version:**

**Install the last stable version:**

**Install the development version:**

**Install a pre-built wheel for a specific CUDA toolkit version:**

**Install the development source distribution:**

**Installing offline:**

Rather than installing and building ArrayFire elsewhere in the system, you can also build directly through python by first setting the`AF_BUILD_LOCAL_LIBS=1` environment variable. Additional setup will be required to build ArrayFire, including satisfying dependencies and further CMake configuration. Details on how to pass additional arguments to the build systems can be found in the[scikit-build documentation.](https://scikit-build.readthedocs.io/en/latest/)

**Post Installation:**

Please follow[these instructions](https://github.com/arrayfire/arrayfire-python/wiki) to ensurethe arrayfire-python can find the arrayfire libraries.

If you are not using one of the pre-built wheels, you may need to ensure arrayfire-python can find the installed arrayfire libraries.Please follow[these instructions](https://github.com/arrayfire/arrayfire-python/wiki) to ensurethat arrayfire-python can find the arrayfire libraries.

To run arrayfire tests, you can run the following command from command line.

c_float_t=ct.c_float

c_double_t=ct.c_double

def_setup():

platform_name=platform.system()

try:

ct.windll.kernel32.SetErrorMode(0x0001|0x0002)

ifAF_SEARCH_PATHisNone:

ifCUDA_PATHisnotNone:

CUDA_FOUND=os.path.isdir(CUDA_PATH+'/bin')andos.path.isdir(CUDA_PATH+'/nvvm/bin/')

ifAF_SEARCH_PATHisNone:

ifos.path.exists('/opt/arrayfire-'+AF_VER_MAJOR+'/'):

elifos.path.exists('/opt/arrayfire/'):

else:

ifCUDA_PATHisNone:

else:

raiseOSError(platform_name+' not supported')

ifAF_PATHisNone:

os.environ['AF_PATH']=AF_SEARCH_PATH

returnpre,post,AF_SEARCH_PATH,CUDA_FOUND

returnpre,post,AF_PATH,AF_SEARCH_PATH,CUDA_FOUND

class_clibrary(object):

def__find_nvrtc_builtins_libname(self,search_path):

filelist=os.listdir(search_path)

forfinfilelist:

if'nvrtc-builtins'inf:

def__libname(self,name,head='af',ver_major=AF_VER_MAJOR):

post=self.__post.replace(_VER_MAJOR_PLACEHOLDER,ver_major)

libname=self.__pre+head+name+post

ifos.path.isdir(self.AF_PATH+'/lib64'):

libname_full=self.AF_PATH+'/lib64/'+libname

ifself.AF_PATH:

ifos.path.isdir(self.AF_PATH+'/lib64'):

path_search=self.AF_PATH+'/lib64/'

else:

path_search=self.AF_PATH+'/lib/'

else:

ifos.path.isdir(self.AF_SEARCH_PATH+'/lib64'):

path_search=self.AF_SEARCH_PATH+'/lib64/'

else:

path_search=self.AF_SEARCH_PATH+'/lib/'

ifplatform.architecture()[0][:2]=='64':

path_site=sys.prefix+'/lib64/'

else:

path_site=sys.prefix+'/lib/'

path_local=self.AF_PYMODULE_PATH

libpaths= [('',libname),

(path_site,libname),

(path_local,libname)]

ifself.AF_PATH:#prefer specified AF_PATH if exists

libpaths.append((path_search,libname))

else:

defset_unsafe(self,name):

lib=self.__clibs[name]

pre,post,AF_PATH,CUDA_FOUND=_setup()

pre,post,AF_PATH,AF_SEARCH_PATH,CUDA_FOUND=_setup()

self.__pre=pre

self.__post=post

self.AF_PATH=AF_PATH

self.AF_SEARCH_PATH=AF_SEARCH_PATH

self.CUDA_FOUND=CUDA_FOUND

af_module=__import__(__name__)

self.AF_PYMODULE_PATH=af_module.__path__[0]+'/'ifaf_module.__path__elseNone

self.__name=None

self.__clibs= {'cuda' :None,

'opencl' :4}

libnames=self.__libname('forge',head='',ver_major=FORGE_VER_MAJOR)

libnames=reversed(self.__libname('forge',head='',ver_major=FORGE_VER_MAJOR))

try:

VERBOSE_LOADS=os.environ['AF_VERBOSE_LOADS']=='1'

forlibnameinlibnames:

try:

ct.cdll.LoadLibrary(libname)

full_libname=libname[0]+libname[1]

ct.cdll.LoadLibrary(full_libname)

ifVERBOSE_LOADS:

print('Loaded '+libname)

print('Loaded '+full_libname)

exceptOSError:

ifVERBOSE_LOADS:

traceback.print_exc()

print('Unable to load '+libname)

print('Unable to load '+full_libname)

fornamein ('cpu','opencl','cuda',''):

libnames=self.__libname(name)

libnames=reversed(self.__libname(name))

forlibnameinlibnames:

try:

ct.cdll.LoadLibrary(libname)

full_libname=libname[0]+libname[1]

ct.cdll.LoadLibrary(full_libname)

clib=ct.CDLL(libname)

clib=ct.CDLL(full_libname)

self.__clibs[__name]=clib

err=clib.af_randu(c_pointer(out),4,c_pointer(dims),Dtype.f32.value)

if (err==ERR.NONE.value):

self.__name=__name

clib.af_release_array(out)

ifVERBOSE_LOADS:

print('Loaded '+libname)

print('Loaded '+full_libname)

ifname=='cuda':

nvrtc_name=self.__find_nvrtc_builtins_libname(libname[0])

ifnvrtc_name:

ct.cdll.LoadLibrary(libname[0]+nvrtc_name)

ifVERBOSE_LOADS:

print('Loaded '+libname[0]+nvrtc_name)

else:

ifVERBOSE_LOADS:

print('Could not find local nvrtc-builtins libarary')

break;

exceptOSError:

ifVERBOSE_LOADS:

traceback.print_exc()

print('Unable to load '+libname)

print('Unable to load '+full_libname)

if (self.__nameisNone):

lst.append(key)

returntuple(lst)

backend=_clibrary()

defset_backend(name,unsafe=False):

[build-system]

requires = ["setuptools","wheel","scikit-build","cmake","ninja"]

name = arrayfire

version = 3.7.20200213

version = 3.8.0

description = Python bindings for ArrayFire

licence = BSD

long_description = file: README.md

long_description_content_type = text/markdown

maintainer = ArrayFire

maintainer_email = technical@arrayfire.com

url = http://arrayfire.com

packages = find:

install_requires=

scikit-build

include = arrayfire

AF_BUILD_LOCAL_LIBS=os.environ.get('AF_BUILD_LOCAL_LIBS')

print(f'AF_BUILD_LOCAL_LIBS={AF_BUILD_LOCAL_LIBS}')

ifAF_BUILD_LOCAL_LIBS:

print('Proceeding to build ArrayFire libraries')

else:

print('Skipping binaries installation, only python files will be installed')

AF_BUILD_CPU=os.environ.get('AF_BUILD_CPU')

AF_BUILD_CPU=1ifAF_BUILD_CPUisNoneelseint(AF_BUILD_CPU)

AF_BUILD_CPU_CMAKE_STR='-DAF_BUILD_CPU:BOOL=ON'if (AF_BUILD_CPU==1)else'-DAF_BUILD_CPU:BOOL=OFF'

AF_BUILD_CUDA=os.environ.get('AF_BUILD_CUDA')

AF_BUILD_CUDA=1ifAF_BUILD_CUDAisNoneelseint(AF_BUILD_CUDA)

AF_BUILD_CUDA_CMAKE_STR='-DAF_BUILD_CUDA:BOOL=ON'if (AF_BUILD_CUDA==1)else'-DAF_BUILD_CUDA:BOOL=OFF'

AF_BUILD_OPENCL=os.environ.get('AF_BUILD_OPENCL')

AF_BUILD_OPENCL=1ifAF_BUILD_OPENCLisNoneelseint(AF_BUILD_OPENCL)

AF_BUILD_OPENCL_CMAKE_STR='-DAF_BUILD_OPENCL:BOOL=ON'if (AF_BUILD_OPENCL==1)else'-DAF_BUILD_OPENCL:BOOL=OFF'

AF_BUILD_UNIFIED=os.environ.get('AF_BUILD_UNIFIED')

AF_BUILD_UNIFIED=1ifAF_BUILD_UNIFIEDisNoneelseint(AF_BUILD_UNIFIED)

AF_BUILD_UNIFIED_CMAKE_STR='-DAF_BUILD_UNIFIED:BOOL=ON'if (AF_BUILD_UNIFIED==1)else'-DAF_BUILD_UNIFIED:BOOL=OFF'

ifAF_BUILD_LOCAL_LIBS:

deffilter_af_files(cmake_manifest):

cmake_manifest=list(filter(lambdaname:not (name.endswith('.h')

orname.endswith('.cpp')

orname.endswith('.hpp')

orname.endswith('.cmake')

orname.endswith('jpg')

orname.endswith('png')

orname.endswith('libaf.so')#avoids duplicates due to symlinks

orre.match('.*libaf\.so\.3\..*',name)isnotNone

orname.endswith('libafcpu.so')

orre.match('.*libafcpu\.so\.3\..*',name)isnotNone

orname.endswith('libafcuda.so')

orre.match('.*libafcuda\.so\.3\..*',name)isnotNone

orname.endswith('libafopencl.so')

orre.match('.*libafopencl\.so\.3\..*',name)isnotNone

orname.endswith('libforge.so')

orre.match('.*libforge\.so\.1\..*',name)isnotNone

or'examples'inname),cmake_manifest))

print('Building CMAKE with following configurable variables: ')

print(AF_BUILD_CPU_CMAKE_STR)

print(AF_BUILD_CUDA_CMAKE_STR)

print(AF_BUILD_OPENCL_CMAKE_STR)

print(AF_BUILD_UNIFIED_CMAKE_STR)

setup(

packages=['arrayfire'],

cmake_install_dir='',

cmake_process_manifest_hook=filter_af_files,

include_package_data=False,

cmake_args=[AF_BUILD_CPU_CMAKE_STR,

AF_BUILD_CUDA_CMAKE_STR,

AF_BUILD_OPENCL_CMAKE_STR,

AF_BUILD_UNIFIED_CMAKE_STR,

'-DCMAKE_BUILD_TYPE:STRING="RelWithDebInfo"',

'-DFG_USE_STATIC_CPPFLAGS:BOOL=OFF',

'-DFG_WITH_FREEIMAGE:BOOL=OFF',

'-DCUDA_architecture_build_targets:STRING=All',

'-DAF_BUILD_DOCS:BOOL=OFF',

'-DAF_BUILD_EXAMPLES:BOOL=OFF',

'-DAF_INSTALL_STANDALONE:BOOL=ON',

'-DAF_WITH_IMAGEIO:BOOL=ON',

'-DAF_WITH_LOGGING:BOOL=ON',

'-DBUILD_TESTING:BOOL=OFF',

'-DAF_BUILD_FORGE:BOOL=ON',

'-DAF_INSTALL_LIB_DIR:STRING=arrayfire',

'-DAF_INSTALL_BIN_DIR:STRING=arrayfire',

'-DFG_INSTALL_LIB_DIR:STRING=arrayfire',

'-DAF_WITH_STATIC_MKL=ON',

]

)

else:

setup()

setup()