def init(backend: tp.Optional[str] = None):
try:
if backend:
af.set_backend(backend)
af.get_device()
except:
af.set_backend('cpu')
def _split_fourier_cuda(self, signal: Signal, step):
'''
This function is called by split_fourier,and should not be used outside
:param signal: signal to traverse the span
:param step: the step of split fourier
:return: None
'''
af.set_backend('cuda')
freq = fftfreq(len(signal.data_sample[0, :]),
(signal.sps * signal.symbol_rate_in_hz)**(-1))
freq = af.Array(freq.ctypes.data, freq.shape, freq.dtype.char)
signal_x = np.asarray(signal.data_sample[0, :])
signal_y = np.asarray(signal.data_sample[1, :])
signal_x = af.Array(signal_x.ctypes.data,
signal_x.shape,
dtype=signal_x.dtype.char)
signal_y = af.Array(signal_y.ctypes.data,
signal_x.shape,
dtype=signal_y.dtype.char)
Disper = (1j / 2) * self.beta2 * (2 * np.pi * freq)**2 * step + (
1j / 6) * self.beta3 * (
(2 * np.pi * freq)**3 * step) - self.alphalin / 2 * step
dz_Eff = (1 - np.exp(-self.alphalin * step)) / self.alphalin
step_number = np.ceil(self.length / step)
for number in range(int(step_number)):
print(number)
if number == step_number - 1:
# dz = step
dz = self.length - (step_number - 1) * step
dz_Eff = (1 - np.exp(-self.alphalin * dz)) / self.alphalin
Disper = (1j / 2) * self.beta2 * (2 * np.pi * freq)**2 * dz + (
1j / 6) * self.beta3 * (
(2 * np.pi * freq)**3 * dz) - self.alphalin / 2 * step
signal_x, signal_y = self.linear(signal_x, signal_y, Disper)
energy = signal_x * af.conjg(signal_x) + signal_y * af.conjg(
signal_y)
signal_x, signal_y = self.nonlinear(energy, signal_x, signal_y,
dz_Eff)
signal_x, signal_y = self.linear(signal_x, signal_y, Disper)
signal_x_array = np.array(signal_x.to_list())
signal_y_array = np.array(signal_y.to_list())
signal_x_array = signal_x_array[:, 0] + 1j * signal_x_array[:, 1]
signal_y_array = signal_y_array[:, 0] + 1j * signal_y_array[:, 1]
signal.data_sample[0, :] = signal_x_array
signal.data_sample[1, :] = signal_y_array
def main():
parser = argparse.ArgumentParser(
description='af vs sklearn logit comparison')
parser.add_argument('-b',
'--backend',
choices=['default', 'cpu', 'cuda', 'opencl'],
default='default',
action='store',
help='ArrayFire backend to be used')
parser.add_argument('-v',
'--device',
type=int,
default=0,
action='store',
help='ArrayFire backend device to be used')
parser.add_argument('-d',
'--dataset',
choices=['iris', 'mnist', 'notmnist'],
default='iris',
action='store',
help='Dataset to be used')
parser.add_argument('-t',
'--type',
choices=['simple', 'predict', 'benchmark'],
default='simple',
action='store',
help='Demo type')
args = parser.parse_args()
af.set_backend(args.backend)
af.set_device(args.device)
af.info()
dataset = None
if args.dataset == 'iris':
dataset = read_and_preprocess_iris_data()
elif args.dataset == 'mnist':
dataset = read_and_preprocess_mnist_data()
elif args.dataset == 'notmnist':
dataset = read_and_preprocess_notmnist_data()
else:
parser.print_help()
return -1
print('------------')
if args.type == 'simple':
demo_simple(arrayfire_knn_demo, sklearn_knn_demo, dataset)
elif args.type == 'predict':
demo_pred(arrayfire_knn_demo, sklearn_knn_demo, dataset)
elif args.type == 'benchmark':
demo_bench(arrayfire_knn_demo, sklearn_knn_demo, dataset)
else:
parser.print_help()
return -1
def init():
# Valid datatypes
global valid_dtypes
valid_dtypes = ('complex32', 'complex64', 'int32', 'int64', 'float32',
'float64')
# Default backend
global default_backend
default_backend = 'numpy'
# Default datatype
global default_dtype
default_dtype = 'float32'
# Defualt FFT Backend
global default_fft_backend
default_fft_backend = 'scipy'
# Default arrayfire backend
global default_arrayfire_backend
default_arrayfire_backend = None
# Determine valid backends based on imports
global valid_backends
valid_backends = ['numpy']
try:
import arrayfire
valid_backends.append('arrayfire')
# Set default arrayfire backend
af_backends = arrayfire.get_available_backends()
if 'cuda' in af_backends:
default_arrayfire_backend = 'cuda'
elif 'opencl' in af_backends:
default_arrayfire_backend = 'opencl'
else:
default_arrayfire_backend = 'cpu'
# set default backend
arrayfire.set_backend(default_arrayfire_backend)
except:
pass
# Determine valid fft backends based on imports
global valid_fft_backends
valid_fft_backends = ['numpy', 'scipy']
try:
import pyfftw
valid_fft_backends.append('fftw')
default_fft_backend = 'fftw'
except:
pass
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
from scipy import special as sp
import arrayfire as af
from dg_maxwell import utils
from dg_maxwell import params
af.set_backend(params.backend)
af.set_device(params.device)
def LGL_points(N):
'''
Calculates : math: `N` Legendre-Gauss-Lobatto (LGL) points.
LGL points are the roots of the polynomial
:math: `(1 - \\xi ** 2) P_{n - 1}'(\\xi) = 0`
Where :math: `P_{n}(\\xi)` are the Legendre polynomials.
This function finds the roots of the above polynomial.
Parameters
----------
N : int
Number of LGL nodes required
Returns
from dg_maxwell import params
from dg_maxwell import wave_equation
import arrayfire as af
af.set_backend('cpu')
af.set_device(0)
def L1_norm(u):
'''
A function to calculate the L1 norm of error using
the polynomial obtained using Lagrange interpolation
Parameters
----------
u : arrayfire.Array [N_LGL N_Elements 1 1]
Difference between analytical and numerical u at the mapped LGL points.
Returns
-------
L1_norm : float64
The L1 norm of error.
'''
interpolated_coeffs = af.reorder(lagrange.lagrange_interpolation_u(\
u), 2, 1, 0)
L1_norm = af.sum(lagrange.integrate(interpolated_coeffs))
return L1_norm
import numpy as np
import arrayfire as af
import time
af.set_backend('cuda')
def test():
x1 =np.arange(2000)
x = af.Array(x1.ctypes.data, x1.shape, x1.dtype.char)
alpha = 2/3
s_old = x[0]
a = time.time()
for i in range(1, 2000):
s = alpha * x[i] + (1- alpha) * s_old
s_old = s
#time.sleep(1)
b = time.time()
print(b - a)
return s
print(test())
#test()
import time
import numpy as np
import arrayfire as af
af.set_backend("opencl")
# This is a benchmark test to compare numpy and arrayfire:
print("The following line displays the ArrayFire build and device details:")
af.info()
aNumPy = np.random.rand(100, 100)
bNumPy = np.random.rand(100, 100)
np_time_start = time.time()
for i in range(1000000):
cNumPy = aNumPy + bNumPy
np_time_end = time.time()
np_time_elapsed = np_time_end - np_time_start
#print("numpy answer is = ", cNumPy)
print("numpy implementation run took time =", np_time_elapsed, " seconds")
aArrayFire = af.Array(aNumPy.ctypes.data, aNumPy.shape, aNumPy.dtype.char)
bArrayFire = af.Array(bNumPy.ctypes.data, bNumPy.shape, bNumPy.dtype.char)
kernel_compilation_time_start = time.time()
cArrayFire = aArrayFire + bArrayFire
af.eval(cArrayFire)
def Set_arrayfire_backend(backend):
if backend not in ['cuda', 'opencl', 'cpu']:
raise ValueError("Must be 'cuda', 'opencl' or 'cpu'")
af.set_backend(backend)
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
import os
from matplotlib import pyplot as pl
from tqdm import trange
import h5py
import numpy as np
import arrayfire as af
af.set_backend('opencl')
af.set_device(0)
import parameters as params
pl.rcParams['figure.figsize'] = 9.6, 6.
pl.rcParams['figure.dpi'] = 100
pl.rcParams['image.cmap'] = 'jet'
pl.rcParams['lines.linewidth'] = 1.5
pl.rcParams['font.family'] = 'serif'
pl.rcParams['font.size'] = 20
pl.rcParams['font.sans-serif'] = 'serif'
pl.rcParams['text.usetex'] = False
pl.rcParams['axes.linewidth'] = 1.5
pl.rcParams['axes.titlesize'] = 'medium'
pl.rcParams['axes.labelsize'] = 'medium'
pl.rcParams['xtick.major.size'] = 8
pl.rcParams['xtick.minor.size'] = 4
pl.rcParams['xtick.major.pad'] = 8
pl.rcParams['xtick.minor.pad'] = 8
def set_backend(proc):
af.set_backend(proc)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Checks that the initialize function initializes the
distribution function array as we expect.
"""
# Importing dependencies:
import numpy as np
from numpy.fft import fftfreq
import arrayfire as af
af.set_backend("cpu")
from petsc4py import PETSc
# Importing solver functions:
from bolt.lib.nonlinear_solver.nonlinear_solver import nonlinear_solver
from bolt.lib.nonlinear_solver.compute_moments \
import compute_moments as compute_moments_imported
from bolt.lib.nonlinear_solver.communicate import communicate_fields
from bolt.lib.nonlinear_solver.apply_boundary_conditions \
import apply_bcs_fields
initialize = nonlinear_solver._initialize
moment_exponents = dict(density=[0, 0, 0],
mom_p1_bulk=[1, 0, 0],
mom_p2_bulk=[0, 1, 0],
mom_p3_bulk=[0, 0, 1],
energy=[2, 2, 2])
#! /usr/bin/env python3 # -*- coding: utf-8 -*- import numpy as np import arrayfire as af backend = 'opencl' device = 0 af.set_backend(backend) af.set_device(device) from dg_maxwell import lagrange from dg_maxwell import isoparam from dg_maxwell import utils from dg_maxwell import msh_parser from dg_maxwell import wave_equation from dg_maxwell import wave_equation_2d # The domain of the function. x_nodes = af.np_to_af_array(np.array([-1., 1.])) # The number of LGL points into which an element is split. N_LGL = 6 # Number of elements the domain is to be divided into. N_Elements = 9 # The scheme to be used for integration. Values are either # 'gauss_quadrature' or 'lobatto_quadrature'
def main():
for backend in af.get_available_backends():
af.set_backend(backend, unsafe=True)
benchmark_current_backend()
