def test_Li_Lj_coeffs():
    '''
    '''
    threshold = 2e-9

    N_LGL = 8

    numerical_L3_xi_L4_eta_coeffs = wave_equation_2d.Li_Lj_coeffs(N_LGL)[:, :,
                                                                         28]

    analytical_L3_xi_L4_eta_coeffs = af.np_to_af_array(np.array([\
            [-129.727857225405, 27.1519390573796, 273.730966722451, - 57.2916772505673\
            , - 178.518337439857, 37.3637484073274, 34.5152279428116, -7.22401021413973], \
            [- 27.1519390573797, 5.68287960923199, 57.2916772505669, - 11.9911032408375,\
            - 37.3637484073272, 7.82020331954072, 7.22401021413968, - 1.51197968793550 ],\
            [273.730966722451, - 57.2916772505680,- 577.583286622990, 120.887730163458,\
            376.680831166362, - 78.8390033617950, - 72.8285112658236, 15.2429504489039],\
            [57.2916772505673, - 11.9911032408381, - 120.887730163459, 25.3017073771593, \
            78.8390033617947, -16.5009417437969, - 15.2429504489039, 3.19033760747451],\
            [- 178.518337439857, 37.3637484073272, 376.680831166362, - 78.8390033617954,\
            - 245.658854496594, 51.4162061168383, 47.4963607700889, - 9.94095116237084],\
            [- 37.3637484073274, 7.82020331954070, 78.8390033617948, - 16.5009417437970,\
            - 51.4162061168385, 10.7613717277423, 9.94095116237085, -2.08063330348620],\
            [34.5152279428116, - 7.22401021413972, - 72.8285112658235, 15.2429504489038,\
            47.4963607700889, - 9.94095116237085, - 9.18307744707700, 1.92201092760671],\
            [7.22401021413973, - 1.51197968793550, -15.2429504489039, 3.19033760747451,\
            9.94095116237084, - 2.08063330348620, - 1.92201092760671, 0.402275383947182]]))

    af.display(numerical_L3_xi_L4_eta_coeffs - analytical_L3_xi_L4_eta_coeffs,
               14)
    assert (af.max(
        af.abs(numerical_L3_xi_L4_eta_coeffs - analytical_L3_xi_L4_eta_coeffs))
            <= threshold)
Beispiel #2
0
def initialize_f(q1, q2, p1, p2, p3, params):

    PETSc.Sys.Print("Initializing f")
    k = params.boltzmann_constant

    params.mu = 0. * q1 + params.initial_mu
    params.T = 0. * q1 + params.initial_temperature
    params.vel_drift_x = 0. * q1
    params.vel_drift_y = 0. * q1
    params.phi = 0. * q1

    params.mu_ee = params.mu.copy()
    params.T_ee = params.T.copy()
    params.vel_drift_x = 0. * q1 + 0e-3
    params.vel_drift_y = 0. * q1 + 0e-3
    params.j_x = 0. * q1
    params.j_y = 0. * q1

    params.E_band = params.band_energy(p1, p2)
    params.vel_band = params.band_velocity(p1, p2)

    E_upper = params.E_band + params.charge[0] * params.phi

    if (params.p_space_grid == 'cartesian'):
        p_x = p1
        p_y = p2
    elif (params.p_space_grid == 'polar2D'):
        p_x = p1 * af.cos(p2)
        p_y = p1 * af.sin(p2)
    else:
        raise NotImplementedError('Unsupported coordinate system in p_space')

    # Initialize to zero
    f = 0 * q1 * p1

    # Parameters to define a gaussian in space (representing a 2D ball)
    A = domain.N_p2  # Amplitude (required for normalization)
    sigma_x = 0.1  # Standard deviation in x
    sigma_y = 0.1  # Standard deviation in y
    x_0 = 0.  # Center in x
    y_0 = 0.  # Center in y

    # TODO: This will work with polar2D coordinates only for the moment
    # Particles lying on the ball need to have the same velocity (direction)
    #theta_0_index = (5*N_p2/8) - 1 # Direction of initial velocity
    theta_0_index = int(4 * domain.N_p2 / 8)  # Direction of initial velocity
    print("Initial angle : ")
    af.display(p2[theta_0_index])

    x, y = coords.get_cartesian_coords(q1, q2)

    f[theta_0_index, :, :]  = A*af.exp(-( (x-x_0)**2/(2*sigma_x**2) + \
                                          (y-y_0)**2/(2*sigma_y**2)
                                        )
                                      )

    af.eval(f)
    return (f)
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = 10 * af.randu(6, 6)
a3 = 10 * af.randu(5, 5, 3)

dx, dy = af.gradient(a)
af.display(dx)
af.display(dy)

af.display(af.resize(a, scale=0.5))
af.display(af.resize(a, odim0=8, odim1=8))

t = af.randu(3, 2)
af.display(af.transform(a, t))
af.display(af.rotate(a, 3.14))
af.display(af.translate(a, 1, 1))
af.display(af.scale(a, 1.2, 1.2, 7, 7))
af.display(af.skew(a, 0.02, 0.02))
h = af.histogram(a, 3)
af.display(h)
af.display(af.hist_equal(a, h))
Beispiel #4
0
if __name__ == "__main__":
    if (len(sys.argv) > 1):
        af.set_device(int(sys.argv[1]))
    af.info()

    print("\n---- Intro to ArrayFire using signed(s32) arrays ----\n")

    h_A = array('i', (1, 2, 4, -1, 2, 0, 4, 2, 3))
    h_B = array('i', (2, 3, 5, 6, 0, 10, -12, 0, 1))

    A = af.Array(h_A, (3, 3))
    B = af.Array(h_B, (3, 3))

    print("\n---- Sub referencing and sub assignment\n")
    af.display(A)
    af.display(A[0, :])
    af.display(A[:, 0])
    A[0, 0] = 11
    A[1] = 100
    af.display(A)
    af.display(B)
    A[1, :] = B[2, :]
    af.display(A)

    print("\n---- Bitwise operations\n")
    af.display(A & B)
    af.display(A | B)
    af.display(A ^ B)

    print("\n---- Transpose\n")
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = 10 * af.randu(6, 6)
a3 = 10 * af.randu(5,5,3)

dx,dy = af.gradient(a)
af.display(dx)
af.display(dy)

af.display(af.resize(a, scale=0.5))
af.display(af.resize(a, odim0=8, odim1=8))

t = af.randu(3,2)
af.display(af.transform(a, t))
af.display(af.rotate(a, 3.14))
af.display(af.translate(a, 1, 1))
af.display(af.scale(a, 1.2, 1.2, 7, 7))
af.display(af.skew(a, 0.02, 0.02))
h = af.histogram(a, 3)
af.display(h)
af.display(af.hist_equal(a, h))
Beispiel #6
0
#load input on device
arr = af.np_to_af_array(input.T)

print(center_of_mass(arr), ndimage.measurements.center_of_mass(input))

normalizer = af.sum(arr)
t_dims = list(arr.dims())
mod_dims = [1] * len(t_dims)

for dim in range(len(t_dims)):
    # swap
    mod_dims[dim] = t_dims[dim]
    t_dims[dim] = 1
    print(mod_dims, t_dims)
    grid = af.iota(mod_dims[0], mod_dims[1], mod_dims[2], tile_dims=t_dims)
    af.display(grid)

af.display(af.iota(mod_dims[0], mod_dims[1], mod_dims[2]))

# results = [np.sum(input * grids[dir].astype(float)) / normalizer
#            for dir in range(input.ndim)]
#
# if numpy.isscalar(results[0]):
#     return tuple(results)
#
# return [tuple(v) for v in numpy.array(results).T]

# d_type
# multiplier = - 0.5 * alpha / pow(sgma[0], 2);
# af::array
# exponent = pow((range(data_dim, 0) - (data_dim[0] - 1) / 2.0).as(f64), 2)*multiplier;
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af
import array as host

a = af.array([1, 2, 3])
af.display(a)
print(a.elements(), a.type(), a.dims(), a.numdims())
print(a.is_empty(), a.is_scalar(), a.is_column(), a.is_row())
print(a.is_complex(), a.is_real(), a.is_double(), a.is_single())
print(a.is_real_floating(), a.is_floating(), a.is_integer(), a.is_bool())

a = af.array(host.array('i', [4, 5, 6]))
af.display(a)
print(a.elements(), a.type(), a.dims(), a.numdims())
print(a.is_empty(), a.is_scalar(), a.is_column(), a.is_row())
print(a.is_complex(), a.is_real(), a.is_double(), a.is_single())
print(a.is_real_floating(), a.is_floating(), a.is_integer(), a.is_bool())

a = af.array(host.array('l', [7, 8, 9] * 3), (3, 3))
af.display(a)
print(a.elements(), a.type(), a.dims(), a.numdims())
print(a.is_empty(), a.is_scalar(), a.is_column(), a.is_row())
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(10, 1)
pos0 = af.randu(10) * 10
af.display(af.approx1(a, pos0))

a = af.randu(3, 3)
pos0 = af.randu(3, 3) * 10
pos1 = af.randu(3, 3) * 10

af.display(af.approx2(a, pos0, pos1))

a = af.randu(8, 1)
af.display(a)

af.display(af.fft(a))
af.display(af.dft(a))
af.display(af.real(af.ifft(af.fft(a))))
af.display(af.real(af.idft(af.dft(a))))

a = af.randu(4, 4)
Beispiel #9
0
 def print(arr, **kwargs):
     af.display(arr)
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(3, 3)

print(af.sum(a), af.product(a), af.min(a), af.max(a), af.count(a), af.any_true(a), af.all_true(a))

af.display(af.sum(a, 0))
af.display(af.sum(a, 1))

af.display(af.product(a, 0))
af.display(af.product(a, 1))

af.display(af.min(a, 0))
af.display(af.min(a, 1))

af.display(af.max(a, 0))
af.display(af.max(a, 1))

af.display(af.count(a, 0))
af.display(af.count(a, 1))

af.display(af.any_true(a, 0))
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af
from arrayfire import parallel_range
import array as host

a = af.randu(5, 5)
af.display(a)
b = af.array(a)
af.display(b)

c = a.copy()
af.display(c)
af.display(a[0,0])
af.display(a[0])
af.display(a[:])
af.display(a[:,:])
af.display(a[0:3,])
af.display(a[-2:-1,-1])
af.display(a[0:5])
af.display(a[0:5:2])

idx = af.array(host.array('i', [0, 3, 2]))
af.display(idx)
Beispiel #12
0
if __name__ == "__main__":
    if (len(sys.argv) > 1):
        af.set_device(int(sys.argv[1]))
    af.info()

    print("\n---- Intro to ArrayFire using signed(s32) arrays ----\n")

    h_A = array('i', ( 1,  2,  4, -1,  2,  0,  4,  2,  3))
    h_B = array('i', ( 2,  3,  5,  6,  0, 10,-12,  0,  1))

    A = af.Array(h_A, (3,3))
    B = af.Array(h_B, (3,3))

    print("\n---- Sub referencing and sub assignment\n")
    af.display(A)
    af.display(A[0,:])
    af.display(A[:,0])
    A[0,0] = 11
    A[1] = 100
    af.display(A)
    af.display(B)
    A[1,:] = B[2,:]
    af.display(A)

    print("\n---- Bitwise operations\n")
    af.display(A & B)
    af.display(A | B)
    af.display(A ^ B)

    print("\n---- Transpose\n")
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(3,3,dtype=af.u32)
b = af.constant(4, 3, 3, dtype=af.u32)
af.display(a)
af.display(b)

c = a + b
d = a
d += b

af.display(c)
af.display(d)
af.display(a + 2)
af.display(3 + a)


c = a - b
d = a
d -= b
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af
import array as host

a = af.array([1, 2, 3])
af.display(a)
print(a.elements(), a.type(), a.dims(), a.numdims())
print(a.is_empty(), a.is_scalar(), a.is_column(), a.is_row())
print(a.is_complex(), a.is_real(), a.is_double(), a.is_single())
print(a.is_real_floating(), a.is_floating(), a.is_integer(), a.is_bool())


a = af.array(host.array("i", [4, 5, 6]))
af.display(a)
print(a.elements(), a.type(), a.dims(), a.numdims())
print(a.is_empty(), a.is_scalar(), a.is_column(), a.is_row())
print(a.is_complex(), a.is_real(), a.is_double(), a.is_single())
print(a.is_real_floating(), a.is_floating(), a.is_integer(), a.is_bool())

a = af.array(host.array("l", [7, 8, 9] * 3), (3, 3))
af.display(a)
print(a.elements(), a.type(), a.dims(), a.numdims())
Beispiel #15
0
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af
from arrayfire import parallel_range
import array as host

a = af.randu(5, 5)
af.display(a)
b = af.array(a)
af.display(b)

c = a.copy()
af.display(c)
af.display(a[0, 0])
af.display(a[0])
af.display(a[:])
af.display(a[:, :])
af.display(a[0:3, ])
af.display(a[-2:-1, -1])
af.display(a[0:5])
af.display(a[0:5:2])

idx = af.array(host.array('i', [0, 3, 2]))
af.display(idx)
Beispiel #16
0
def initialize_f(q1, q2, p1, p2, p3, params):

    PETSc.Sys.Print("Initializing f")
    k = params.boltzmann_constant

    params.mu = 0. * q1 + params.initial_mu
    params.T = 0. * q1 + params.initial_temperature
    params.vel_drift_x = 0. * q1
    params.vel_drift_y = 0. * q1
    params.phi = 0. * q1

    params.mu_ee = params.mu.copy()
    params.T_ee = params.T.copy()
    params.vel_drift_x = 0. * q1 + 0e-3
    params.vel_drift_y = 0. * q1 + 0e-3
    params.j_x = 0. * q1
    params.j_y = 0. * q1

    params.E_band = params.band_energy(p1, p2)
    params.vel_band = params.band_velocity(p1, p2)

    E_upper = params.E_band + params.charge[0] * params.phi

    if (params.p_space_grid == 'cartesian'):
        p_x = p1
        p_y = p2
    elif (params.p_space_grid == 'polar2D'):
        p_x = p1 * af.cos(p2)
        p_y = p1 * af.sin(p2)
    else:
        raise NotImplementedError('Unsupported coordinate system in p_space')

    # Initialize to zero
    f = 0 * q1 * p1

    # Parameters to define a gaussian in space (representing a 2D ball)
    A = domain.N_p2  # Amplitude (required for normalization)
    sigma_x = 0.05  # Standard deviation in x
    sigma_y = 0.05  # Standard deviation in y
    x_0 = 0.  # Center in x
    y_0 = 0.  # Center in y

    # TODO: This will work with polar2D p-space only for the moment
    # Particles lying on the ball need to have the same velocity (direction)
    #theta_0_index = (5*N_p2/8) - 1 # Direction of initial velocity
    theta_0_index = int(5 * domain.N_p2 / 8)  # Direction of initial velocity

    print("Initial angle : ")
    af.display(p2[theta_0_index])

    # Load shift indices for all 4 boundaries into params. Required to perform
    # mirroring operations along boundaries at arbitrary angles.
    params.shift_indices_left, params.shift_indices_right, \
    params.shift_indices_bottom, params.shift_indices_top = \
            compute_shift_indices(q1, q2, p1, p2, p3, params)

    x, y = coords.get_cartesian_coords(q1, q2)

    #    f[theta_0_index, :, :]  = A + A*af.exp(-( (x-x_0)**2/(2*sigma_x**2) + \
    #                                          (y-y_0)**2/(2*sigma_y**2)
    #                                        )
    #                                      )
    f = (1. / (af.exp(
        (E_upper - params.vel_drift_x * p_x - params.vel_drift_y * p_y -
         params.mu) / (k * params.T)) + 1.))

    af.eval(f)
    return (f)
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(5, 5)
b = af.randu(5, 5)

af.display(af.matmul(a, b))
af.display(af.matmul(a, b, af.AF_MAT_TRANS))
af.display(af.matmul(a, b, af.AF_MAT_NONE, af.AF_MAT_TRANS))

b = af.randu(5, 1)
af.display(af.dot(b, b))
Beispiel #18
0
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(3, 3, dtype=af.u32)
b = af.constant(4, 3, 3, dtype=af.u32)
af.display(a)
af.display(b)

c = a + b
d = a
d += b

af.display(c)
af.display(d)
af.display(a + 2)
af.display(3 + a)

c = a - b
d = a
d -= b

af.display(c)
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(3, 3)

print(af.sum(a), af.product(a), af.min(a), af.max(a), af.count(a),
      af.any_true(a), af.all_true(a))

af.display(af.sum(a, 0))
af.display(af.sum(a, 1))

af.display(af.product(a, 0))
af.display(af.product(a, 1))

af.display(af.min(a, 0))
af.display(af.min(a, 1))

af.display(af.max(a, 0))
af.display(af.max(a, 1))

af.display(af.count(a, 0))
af.display(af.count(a, 1))

af.display(af.any_true(a, 0))
Beispiel #20
0
#!/usr/bin/python

#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

# Display backend information
af.info()

# Generate a uniform random array with a size of 5 elements
a = af.randu(5, 1)

# Print a and its minimum value
af.display(a)

# Print min and max values of a
print("Minimum, Maximum: ", af.min(a), af.max(a))
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af

a = af.randu(5, 5)

l, u, p = af.lu(a)

af.display(l)
af.display(u)
af.display(p)

p = af.lu_inplace(a, "full")

af.display(a)
af.display(p)

a = af.randu(5, 3)

q, r, t = af.qr(a)

af.display(q)
af.display(r)
af.display(t)
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

af.display(af.constant(100, 3,3, dtype=af.f32))
af.display(af.constant(25, 3,3, dtype=af.c32))
af.display(af.constant(2**50, 3,3, dtype=af.s64))
af.display(af.constant(2+3j, 3,3))
af.display(af.constant(3+5j, 3,3, dtype=af.c32))

af.display(af.range(3, 3))
af.display(af.iota(3, 3, tile_dims=(2,2)))

af.display(af.randu(3, 3, 1, 2))
af.display(af.randu(3, 3, 1, 2, af.b8))
af.display(af.randu(3, 3, dtype=af.c32))

af.display(af.randn(3, 3, 1, 2))
af.display(af.randn(3, 3, dtype=af.c32))

af.set_seed(1024)
assert(af.get_seed() == 1024)
Beispiel #23
0
def display(array: ndarray):
    if isinstance(array, ndarray):
        af.display(array._af_array)
    else:
        print(array)
Beispiel #24
0
def initialize_f(q1, q2, p1, p2, p3, params):

    PETSc.Sys.Print("Initializing f")
    k = params.boltzmann_constant

    params.mu = 0. * q1 + params.initial_mu
    params.T = 0. * q1 + params.initial_temperature
    params.vel_drift_x = 0. * q1
    params.vel_drift_y = 0. * q1

    params.mu_ee = params.mu.copy()
    params.T_ee = params.T.copy()
    params.vel_drift_x = 0. * q1 + 0e-3
    params.vel_drift_y = 0. * q1 + 0e-3
    params.j_x = 0. * q1
    params.j_y = 0. * q1

    params.p_x, params.p_y = params.get_p_x_and_p_y(p1, p2)
    params.E_band = params.band_energy(p1, p2)
    params.vel_band = params.band_velocity(p1, p2)

    # TODO: Injecting get_cartesian_coords into params to avoid circular dependency
    params.get_cartesian_coords = coords.get_cartesian_coords

    # Load shift indices for all 4 boundaries into params. Required to perform
    # mirroring operations along boundaries at arbitrary angles.
    params.shift_indices_left, params.shift_indices_right, \
    params.shift_indices_bottom, params.shift_indices_top = \
            compute_shift_indices(q1, q2, p1, p2, p3, params)

    params.x, params.y = coords.get_cartesian_coords(
        q1,
        q2,
        q1_start_local_left=params.q1_start_local_left,
        q2_start_local_bottom=params.q2_start_local_bottom)

    # TODO : Testing : Dump left, bottom, right, top faces also
    d_q1 = (q1[0, 0, 1, 0] - q1[0, 0, 0, 0]).scalar()
    d_q2 = (q2[0, 0, 0, 1] - q2[0, 0, 0, 0]).scalar()

    q1_left_faces = q1 - 0.5 * d_q1
    q2_bottom_faces = q2 - 0.5 * d_q2

    q1_right_faces = q1 + 0.5 * d_q1
    q2_top_faces = q2 + 0.5 * d_q2

    params.x_top_center, params.y_top_center = coords.get_cartesian_coords(
        q1,
        q2_top_faces,
        q1_start_local_left=params.q1_start_local_left,
        q2_start_local_bottom=params.q2_start_local_bottom)

    params.x_right_center, params.y_right_center = coords.get_cartesian_coords(
        q1_right_faces,
        q2,
        q1_start_local_left=params.q1_start_local_left,
        q2_start_local_bottom=params.q2_start_local_bottom)

    params.q1 = q1
    params.q2 = q2
    [[params.dx_dq1, params.dx_dq2], [params.dy_dq1, params.dy_dq2]
     ] = jacobian_dx_dq(q1,
                        q2,
                        q1_start_local_left=params.q1_start_local_left,
                        q2_start_local_bottom=params.q2_start_local_bottom)
    [[params.dq1_dx, params.dq1_dy], [params.dq2_dx, params.dq2_dy]
     ] = jacobian_dq_dx(q1,
                        q2,
                        q1_start_local_left=params.q1_start_local_left,
                        q2_start_local_bottom=params.q2_start_local_bottom)
    params.sqrt_det_g = sqrt_det_g(
        q1,
        q2,
        q1_start_local_left=params.q1_start_local_left,
        q2_start_local_bottom=params.q2_start_local_bottom)

    # Calculation of integral measure
    # Evaluating velocity space resolution for each species:
    dp1 = []
    dp2 = []
    dp3 = []
    N_p1 = domain.N_p1
    N_p2 = domain.N_p2
    N_p3 = domain.N_p3
    p1_start = domain.p1_start
    p1_end = domain.p1_end
    p2_start = domain.p2_start
    p2_end = domain.p2_end
    p3_start = domain.p3_start
    p3_end = domain.p3_end

    N_species = len(params.mass)
    for i in range(N_species):
        dp1.append((p1_end[i] - p1_start[i]) / N_p1)
        dp2.append((p2_end[i] - p2_start[i]) / N_p2)
        dp3.append((p3_end[i] - p3_start[i]) / N_p3)

    theta = af.atan(params.p_y / params.p_x)
    p_f = params.fermi_momentum_magnitude(theta)

    if (params.p_space_grid == 'cartesian'):
        dp_x = dp1[0]
        dp_y = dp2[0]
        dp_z = dp3[0]
        params.integral_measure = \
          (4./(2.*np.pi*params.h_bar)**2) * dp_z * dp_y * dp_x

    elif (params.p_space_grid == 'polar2D'):
        # In polar2D coordinates, p1 = radius and p2 = theta
        # Integral : \int delta(r - r_F) F(r, theta) r dr dtheta
        r = p1
        theta = p2
        dp_r = dp1[0]
        dp_theta = dp2[0]

        if (params.zero_temperature):
            # Assumption : F(r, theta) = delta(r-r_F)*F(theta)
            params.integral_measure = \
              (4./(2.*np.pi*params.h_bar)**2) * p_f * dp_theta

        else:
            params.integral_measure = \
              (4./(2.*np.pi*params.h_bar)**2) * r * dp_r * dp_theta

    else:
        raise NotImplementedError('Unsupported coordinate system in p_space')

    # Initialize to zero
    f = 0 * q1 * p1

    # Parameters to define a gaussian in space (representing a 2D ball)
    A = domain.N_p2  # Amplitude (required for normalization)
    sigma_x = 0.05  # Standard deviation in x
    sigma_y = 0.05  # Standard deviation in y
    x_0 = -0.7  # Center in x
    y_0 = 0.  # Center in y

    # TODO: This will work with polar2D p-space only for the moment
    # Particles lying on the ball need to have the same velocity (direction)
    #theta_0_index = (5*N_p2/8) - 1 # Direction of initial velocity
    theta_0_index = int(4 * domain.N_p2 / 8)  # Direction of initial velocity

    print("Initial angle : ")
    af.display(p2[theta_0_index])

    #    f[theta_0_index, :, :]  = A*af.exp(-( (params.x-x_0)**2/(2*sigma_x**2) + \
    #                                          (params.y-y_0)**2/(2*sigma_y**2)
    #                                        )
    #                                      ) +  A*af.exp(-( (params.x-x_0)**2/(2*sigma_x**2) + \
    #                                          (params.y-(-0.5))**2/(2*sigma_y**2)
    #                                        )
    #                                      ) + A*af.exp(-( (params.x-x_0)**2/(2*sigma_x**2) + \
    #                                          (params.y-0.5)**2/(2*sigma_y**2)
    #                                        )
    #                                      )

    f[theta_0_index, :, :] = A * af.exp(-((params.x - x_0)**2 /
                                          (2 * sigma_x**2)))

    af.eval(f)
    return (f)
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(5, 5)
b = af.randu(5, 5)
w = af.randu(5, 1)

af.display(af.mean(a, dim=0))
af.display(af.mean(a, weights=w, dim=0))
print(af.mean(a))
print(af.mean(a, weights=w))

af.display(af.var(a, dim=0))
af.display(af.var(a, isbiased=True, dim=0))
af.display(af.var(a, weights=w, dim=0))
print(af.var(a))
print(af.var(a, isbiased=True))
print(af.var(a, weights=w))

af.display(af.stdev(a, dim=0))
print(af.stdev(a))

af.display(af.var(a, dim=0))
#!/usr/bin/python
#######################################################
# Copyright (c) 2015, ArrayFire
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

a = af.randu(10, 1)
pos0 = af.randu(10) * 10
af.display(af.approx1(a, pos0))

a = af.randu(3, 3)
pos0 = af.randu(3, 3) * 10
pos1 = af.randu(3, 3) * 10

af.display(af.approx2(a, pos0, pos1))

a = af.randu(8, 1)
af.display(a)

af.display(af.fft(a))
af.display(af.dft(a))
af.display(af.real(af.ifft(af.fft(a))))
af.display(af.real(af.idft(af.dft(a))))

a = af.randu(4, 4)
# All rights reserved.
#
# This file is distributed under 3-clause BSD license.
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################

import arrayfire as af

try:
    # Display backend information
    af.info()

    print("Create a 5-by-3 matrix of random floats on the GPU\n")
    A = af.randu(5, 3, 1, 1, af.Dtype.f32)
    af.display(A)

    print("Element-wise arithmetic\n")
    B = af.sin(A) + 1.5
    af.display(B)

    print("Negate the first three elements of second column\n")
    B[0:3, 1] = B[0:3, 1] * -1
    af.display(B)

    print("Fourier transform the result\n");
    C = af.fft(B);
    af.display(C);

    print("Grab last row\n");
    c = C[-1,:];