def minmod(x, y, z):
min_of_all = af.minof(af.minof(af.abs(x),af.abs(y)), af.abs(z))
# af.sign(x) = 1 for x<0 and sign(x) for x>0:
signx = 1 - 2 * af.sign(x)
signy = 1 - 2 * af.sign(y)
signz = 1 - 2 * af.sign(z)
result = 0.25 * af.abs(signx + signy) * (signx + signz) * min_of_all
af.eval(result)
return result
def simple_arith(verbose = False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
a = af.randu(3,3,dtype=af.Dtype.u32)
b = af.constant(4, 3, 3, dtype=af.Dtype.u32)
display_func(a)
display_func(b)
c = a + b
d = a
d += b
display_func(c)
display_func(d)
display_func(a + 2)
display_func(3 + a)
c = a - b
d = a
d -= b
display_func(c)
display_func(d)
display_func(a - 2)
display_func(3 - a)
c = a * b
d = a
d *= b
display_func(c * 2)
display_func(3 * d)
display_func(a * 2)
display_func(3 * a)
c = a / b
d = a
d /= b
display_func(c / 2.0)
display_func(3.0 / d)
display_func(a / 2)
display_func(3 / a)
c = a % b
d = a
d %= b
display_func(c % 2.0)
display_func(3.0 % d)
display_func(a % 2)
display_func(3 % a)
c = a ** b
d = a
d **= b
display_func(c ** 2.0)
display_func(3.0 ** d)
display_func(a ** 2)
display_func(3 ** a)
display_func(a < b)
display_func(a < 0.5)
display_func(0.5 < a)
display_func(a <= b)
display_func(a <= 0.5)
display_func(0.5 <= a)
display_func(a > b)
display_func(a > 0.5)
display_func(0.5 > a)
display_func(a >= b)
display_func(a >= 0.5)
display_func(0.5 >= a)
display_func(a != b)
display_func(a != 0.5)
display_func(0.5 != a)
display_func(a == b)
display_func(a == 0.5)
display_func(0.5 == a)
display_func(a & b)
display_func(a & 2)
c = a
c &= 2
display_func(c)
display_func(a | b)
display_func(a | 2)
c = a
c |= 2
display_func(c)
display_func(a >> b)
display_func(a >> 2)
c = a
c >>= 2
display_func(c)
display_func(a << b)
display_func(a << 2)
c = a
c <<= 2
display_func(c)
display_func(-a)
display_func(+a)
display_func(~a)
display_func(a)
display_func(af.cast(a, af.Dtype.c32))
display_func(af.maxof(a,b))
display_func(af.minof(a,b))
display_func(af.rem(a,b))
a = af.randu(3,3) - 0.5
b = af.randu(3,3) - 0.5
display_func(af.abs(a))
display_func(af.arg(a))
display_func(af.sign(a))
display_func(af.round(a))
display_func(af.trunc(a))
display_func(af.floor(a))
display_func(af.ceil(a))
display_func(af.hypot(a, b))
display_func(af.sin(a))
display_func(af.cos(a))
display_func(af.tan(a))
display_func(af.asin(a))
display_func(af.acos(a))
display_func(af.atan(a))
display_func(af.atan2(a, b))
c = af.cplx(a)
d = af.cplx(a,b)
display_func(c)
display_func(d)
display_func(af.real(d))
display_func(af.imag(d))
display_func(af.conjg(d))
display_func(af.sinh(a))
display_func(af.cosh(a))
display_func(af.tanh(a))
display_func(af.asinh(a))
display_func(af.acosh(a))
display_func(af.atanh(a))
a = af.abs(a)
b = af.abs(b)
display_func(af.root(a, b))
display_func(af.pow(a, b))
display_func(af.pow2(a))
display_func(af.exp(a))
display_func(af.expm1(a))
display_func(af.erf(a))
display_func(af.erfc(a))
display_func(af.log(a))
display_func(af.log1p(a))
display_func(af.log10(a))
display_func(af.log2(a))
display_func(af.sqrt(a))
display_func(af.cbrt(a))
a = af.round(5 * af.randu(3,3) - 1)
b = af.round(5 * af.randu(3,3) - 1)
display_func(af.factorial(a))
display_func(af.tgamma(a))
display_func(af.lgamma(a))
display_func(af.iszero(a))
display_func(af.isinf(a/b))
display_func(af.isnan(a/a))
a = af.randu(5, 1)
b = af.randu(1, 5)
c = af.broadcast(lambda x,y: x+y, a, b)
display_func(a)
display_func(b)
display_func(c)
@af.broadcast
def test_add(aa, bb):
return aa + bb
display_func(test_add(a, b))
def simple_arith(verbose=False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
a = af.randu(3, 3)
b = af.constant(4, 3, 3)
display_func(a)
display_func(b)
c = a + b
d = a
d += b
display_func(c)
display_func(d)
display_func(a + 2)
display_func(3 + a)
c = a - b
d = a
d -= b
display_func(c)
display_func(d)
display_func(a - 2)
display_func(3 - a)
c = a * b
d = a
d *= b
display_func(c * 2)
display_func(3 * d)
display_func(a * 2)
display_func(3 * a)
c = a / b
d = a
d /= b
display_func(c / 2.0)
display_func(3.0 / d)
display_func(a / 2)
display_func(3 / a)
c = a % b
d = a
d %= b
display_func(c % 2.0)
display_func(3.0 % d)
display_func(a % 2)
display_func(3 % a)
c = a**b
d = a
d **= b
display_func(c**2.0)
display_func(3.0**d)
display_func(a**2)
display_func(3**a)
display_func(a < b)
display_func(a < 0.5)
display_func(0.5 < a)
display_func(a <= b)
display_func(a <= 0.5)
display_func(0.5 <= a)
display_func(a > b)
display_func(a > 0.5)
display_func(0.5 > a)
display_func(a >= b)
display_func(a >= 0.5)
display_func(0.5 >= a)
display_func(a != b)
display_func(a != 0.5)
display_func(0.5 != a)
display_func(a == b)
display_func(a == 0.5)
display_func(0.5 == a)
a = af.randu(3, 3, dtype=af.Dtype.u32)
b = af.constant(4, 3, 3, dtype=af.Dtype.u32)
display_func(a & b)
display_func(a & 2)
c = a
c &= 2
display_func(c)
display_func(a | b)
display_func(a | 2)
c = a
c |= 2
display_func(c)
display_func(a >> b)
display_func(a >> 2)
c = a
c >>= 2
display_func(c)
display_func(a << b)
display_func(a << 2)
c = a
c <<= 2
display_func(c)
display_func(-a)
display_func(+a)
display_func(~a)
display_func(a)
display_func(af.cast(a, af.Dtype.c32))
display_func(af.maxof(a, b))
display_func(af.minof(a, b))
display_func(af.rem(a, b))
a = af.randu(3, 3) - 0.5
b = af.randu(3, 3) - 0.5
display_func(af.abs(a))
display_func(af.arg(a))
display_func(af.sign(a))
display_func(af.round(a))
display_func(af.trunc(a))
display_func(af.floor(a))
display_func(af.ceil(a))
display_func(af.hypot(a, b))
display_func(af.sin(a))
display_func(af.cos(a))
display_func(af.tan(a))
display_func(af.asin(a))
display_func(af.acos(a))
display_func(af.atan(a))
display_func(af.atan2(a, b))
c = af.cplx(a)
d = af.cplx(a, b)
display_func(c)
display_func(d)
display_func(af.real(d))
display_func(af.imag(d))
display_func(af.conjg(d))
display_func(af.sinh(a))
display_func(af.cosh(a))
display_func(af.tanh(a))
display_func(af.asinh(a))
display_func(af.acosh(a))
display_func(af.atanh(a))
a = af.abs(a)
b = af.abs(b)
display_func(af.root(a, b))
display_func(af.pow(a, b))
display_func(af.pow2(a))
display_func(af.sigmoid(a))
display_func(af.exp(a))
display_func(af.expm1(a))
display_func(af.erf(a))
display_func(af.erfc(a))
display_func(af.log(a))
display_func(af.log1p(a))
display_func(af.log10(a))
display_func(af.log2(a))
display_func(af.sqrt(a))
display_func(af.cbrt(a))
a = af.round(5 * af.randu(3, 3) - 1)
b = af.round(5 * af.randu(3, 3) - 1)
display_func(af.factorial(a))
display_func(af.tgamma(a))
display_func(af.lgamma(a))
display_func(af.iszero(a))
display_func(af.isinf(a / b))
display_func(af.isnan(a / a))
a = af.randu(5, 1)
b = af.randu(1, 5)
c = af.broadcast(lambda x, y: x + y, a, b)
display_func(a)
display_func(b)
display_func(c)
@af.broadcast
def test_add(aa, bb):
return aa + bb
display_func(test_add(a, b))
# 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.info()
ITERATIONS = 200
POINTS = int(10.0 * ITERATIONS)
Z = 1 + af.range(POINTS) / ITERATIONS
win = af.Window(800, 800, "3D Plot example using ArrayFire")
t = 0.1
while not win.close():
X = af.cos(Z * t + t) / Z
Y = af.sin(Z * t + t) / Z
X = af.maxof(af.minof(X, 1), -1)
Y = af.maxof(af.minof(Y, 1), -1)
Pts = af.join(1, X, Y, Z)
win.plot3(Pts)
t = t + 0.01
af.display(c) af.display(a << b) af.display(a << 2) c = a c <<= 2 af.display(c) af.display(-a) af.display(+a) af.display(~a) af.display(a) af.display(af.cast(a, af.c32)) af.display(af.maxof(a, b)) af.display(af.minof(a, b)) af.display(af.rem(a, b)) a = af.randu(3, 3) - 0.5 b = af.randu(3, 3) - 0.5 af.display(af.abs(a)) af.display(af.arg(a)) af.display(af.sign(a)) af.display(af.round(a)) af.display(af.trunc(a)) af.display(af.floor(a)) af.display(af.ceil(a)) af.display(af.hypot(a, b)) af.display(af.sin(a)) af.display(af.cos(a))
def reconstruct_ppm(input_array, axis):
if(axis == 0):
x0_shift = 2; y0_shift = 0; z0_shift = 0
x1_shift = 1; y1_shift = 0; z1_shift = 0
x3_shift = -1; y3_shift = 0; z3_shift = 0
x4_shift = -2; y4_shift = 0; z4_shift = 0
elif(axis == 1):
x0_shift = 0; y0_shift = 2; z0_shift = 0
x1_shift = 0; y1_shift = 1; z1_shift = 0
x3_shift = 0; y3_shift = -1; z3_shift = 0
x4_shift = 0; y4_shift = -2; z4_shift = 0
elif(axis == 2):
x0_shift = 0; y0_shift = 0; z0_shift = 2
x1_shift = 0; y1_shift = 0; z1_shift = 1
x3_shift = 0; y3_shift = 0; z3_shift = -1
x4_shift = 0; y4_shift = 0; z4_shift = -2
else:
raise Exception('Invalid choice for axis')
y0 = af.shift(input_array, x0_shift, y0_shift, z0_shift)
y1 = af.shift(input_array, x1_shift, y1_shift, z1_shift)
y2 = input_array;
y3 = af.shift(input_array, x3_shift, y3_shift, z3_shift)
y4 = af.shift(input_array, x4_shift, y4_shift, z4_shift)
# Approximants for slopes
d0 = 2 * (y1-y0)
d1 = 2 * (y2-y1)
d2 = 2 * (y3-y2)
d3 = 2 * (y4-y3)
D1 = 0.5 * (y2-y0)
D2 = 0.5 * (y3-y1)
D3 = 0.5 * (y4-y2)
cond_zero_slope1 = (d1 * d0 <= 0)
sign1 = (D1 > 0) * 2 - 1
DQ1 = (1 - cond_zero_slope1) * sign1 * \
af.minof(af.abs(D1),af.minof(af.abs(d0),af.abs(d1)))
cond_zero_slope2 = (d2 * d1 <= 0)
sign2 = (D2 > 0) * 2 - 1
DQ2 = (1 - cond_zero_slope2) * sign2 * \
af.minof(af.abs(D2),af.minof(af.abs(d1),af.abs(d2)))
cond_zero_slope3 = (d3 * d2 <= 0)
sign3 = (D3 > 0) * 2 - 1;
DQ3 = (1 - cond_zero_slope3) * sign3 * \
af.minof(af.abs(D3),af.minof(af.abs(d2),af.abs(d3)))
# Base high-order PPM reconstruction
left_value = 0.5 * (y2 + y1) - (DQ2-DQ1)/6
right_value = 0.5 * (y3 + y2) - (DQ3-DQ2)/6
# Corrections
corr1 = ((right_value - y2) * (y2 - left_value) <= 0)
qd = right_value - left_value
qe = 6 * (y2 - 0.5 * (right_value + left_value))
corr2 = (qd * (qd - qe) < 0)
corr3 = (qd * (qd + qe) < 0)
left_value = left_value * (1 - corr1) + corr1 * y2;
right_value = right_value * (1 - corr1) + corr1 * y2;
left_value = left_value * (1 - corr2) + corr2 * (3 * y2 - 2 * right_value)
right_value = right_value * corr2 + (1 - corr2) * right_value * (1 - corr3) + \
(1 - corr2) * corr3 * (3 * y2 - 2 * left_value)
return(left_value, right_value)
def reconstruct_ppm(input_array, axis):
"""
Reconstructs the input array using PPM
reconstruction.
Parameters
----------
input_array: af.Array
Array holding the cells data.
axis: int
Axis along which the reconstruction method is to be applied.
"""
if (axis == 0):
x0_shift = 2
y0_shift = 0
z0_shift = 0
w0_shift = 0
x1_shift = 1
y1_shift = 0
z1_shift = 0
w1_shift = 0
x3_shift = -1
y3_shift = 0
z3_shift = 0
w3_shift = 0
x4_shift = -2
y4_shift = 0
z4_shift = 0
w4_shift = 0
elif (axis == 1):
x0_shift = 0
y0_shift = 2
z0_shift = 0
w0_shift = 0
x1_shift = 0
y1_shift = 1
z1_shift = 0
w1_shift = 0
x3_shift = 0
y3_shift = -1
z3_shift = 0
w3_shift = 0
x4_shift = 0
y4_shift = -2
z4_shift = 0
w4_shift = 0
elif (axis == 2):
x0_shift = 0
y0_shift = 0
z0_shift = 2
w0_shift = 0
x1_shift = 0
y1_shift = 0
z1_shift = 1
w1_shift = 0
x3_shift = 0
y3_shift = 0
z3_shift = -1
w3_shift = 0
x4_shift = 0
y4_shift = 0
z4_shift = -2
w4_shift = 0
elif (axis == 3):
x0_shift = 0
y0_shift = 0
z0_shift = 0
w0_shift = 2
x1_shift = 0
y1_shift = 0
z1_shift = 0
w1_shift = 1
x3_shift = 0
y3_shift = 0
z3_shift = 0
w3_shift = -1
x4_shift = 0
y4_shift = 0
z4_shift = 0
w4_shift = -2
else:
raise Exception('Invalid choice for axis')
y0 = af.shift(input_array, x0_shift, y0_shift, z0_shift, w0_shift)
y1 = af.shift(input_array, x1_shift, y1_shift, z1_shift, w1_shift)
y2 = input_array
y3 = af.shift(input_array, x3_shift, y3_shift, z3_shift, w3_shift)
y4 = af.shift(input_array, x4_shift, y4_shift, z4_shift, w4_shift)
# Approximants for slopes
d0 = 2 * (y1 - y0)
d1 = 2 * (y2 - y1)
d2 = 2 * (y3 - y2)
d3 = 2 * (y4 - y3)
D1 = 0.5 * (y2 - y0)
D2 = 0.5 * (y3 - y1)
D3 = 0.5 * (y4 - y2)
cond_zero_slope1 = (d1 * d0 <= 0)
sign1 = (D1 > 0) * 2 - 1
DQ1 = (1 - cond_zero_slope1) * sign1 * \
af.minof(af.abs(D1),af.minof(af.abs(d0),af.abs(d1)))
cond_zero_slope2 = (d2 * d1 <= 0)
sign2 = (D2 > 0) * 2 - 1
DQ2 = (1 - cond_zero_slope2) * sign2 * \
af.minof(af.abs(D2),af.minof(af.abs(d1),af.abs(d2)))
cond_zero_slope3 = (d3 * d2 <= 0)
sign3 = (D3 > 0) * 2 - 1
DQ3 = (1 - cond_zero_slope3) * sign3 * \
af.minof(af.abs(D3),af.minof(af.abs(d2),af.abs(d3)))
# Base high-order PPM reconstruction
left_value = 0.5 * (y2 + y1) - (DQ2 - DQ1) / 6
right_value = 0.5 * (y3 + y2) - (DQ3 - DQ2) / 6
# Corrections
corr1 = ((right_value - y2) * (y2 - left_value) <= 0)
qd = right_value - left_value
qe = 6 * (y2 - 0.5 * (right_value + left_value))
corr2 = (qd * (qd - qe) < 0)
corr3 = (qd * (qd + qe) < 0)
left_value = left_value * (1 - corr1) + corr1 * y2
right_value = right_value * (1 - corr1) + corr1 * y2
left_value = left_value * (1 - corr2) + corr2 * (3 * y2 - 2 * right_value)
right_value = right_value * corr2 + (1 - corr2) * right_value * (1 - corr3) + \
(1 - corr2) * corr3 * (3 * y2 - 2 * left_value)
return (left_value, right_value)
af.display(c) af.display(a << b) af.display(a << 2) c = a c <<= 2 af.display(c) af.display(-a) af.display(+a) af.display(~a) af.display(a) af.display(af.cast(a, af.c32)) af.display(af.maxof(a,b)) af.display(af.minof(a,b)) af.display(af.rem(a,b)) a = af.randu(3,3) - 0.5 b = af.randu(3,3) - 0.5 af.display(af.abs(a)) af.display(af.arg(a)) af.display(af.sign(a)) af.display(af.round(a)) af.display(af.trunc(a)) af.display(af.floor(a)) af.display(af.ceil(a)) af.display(af.hypot(a, b)) af.display(af.sin(a)) af.display(af.cos(a))
def advection_step(u, v):
'''
done - Matching u_new and v_new
'''
u_w_bc, v_w_bc = add_boundary_conditions(u, v)
u = af.moddims(u_w_bc, params.n, params.n)
v = af.moddims(v_w_bc, params.n, params.n)
u_tile = u[1:-1, 1:-1]
v_tile = v[1:-1, 1:-1]
u_new = af.np_to_af_array(np.zeros([params.n, params.n]))
v_new = af.np_to_af_array(np.zeros([params.n, params.n]))
x0_tile = af.tile(af.np_to_af_array(np.linspace(0, 1, params.n)), 1,
params.n)[1:-1, 1:-1]
y0_tile = af.transpose(x0_tile)
reference_0_tile = af.constant(0,
params.n - 2,
params.n - 2,
dtype=af.Dtype.f64)
reference_1_tile = af.constant(1,
params.n - 2,
params.n - 2,
dtype=af.Dtype.f64)
x1_tile = af.minof(
af.maxof(x0_tile - params.delta_t * u_tile, reference_0_tile),
reference_1_tile)
y1_tile = af.minof(
af.maxof(y0_tile - params.delta_t * v_tile, reference_0_tile),
reference_1_tile)
i_left_tile = af.minof(af.cast(x1_tile * (params.n - 1), af.Dtype.s64),
(params.n - 2) * reference_1_tile)
i_left_flat = af.flat(i_left_tile)
i_right_tile = i_left_tile + 1
i_right_flat = af.flat(i_right_tile)
j_bottom_tile = af.minof(af.cast(y1_tile * (params.n - 1), af.Dtype.s64),
(params.n - 2) * reference_1_tile)
j_bottom_flat = af.flat(j_bottom_tile * params.n)
j_top_tile = j_bottom_tile + 1
j_top_flat = af.flat(j_top_tile * params.n)
x_left_tile = i_left_tile / (params.n - 1)
x_right_tile = i_right_tile / (params.n - 1)
y_bottom_tile = j_bottom_tile / (params.n - 1)
y_top_tile = j_top_tile / (params.n - 1)
print(x_left_tile)
flat_u = af.flat(u)
flat_v = af.flat(v)
u_top_left_tile = af.moddims(flat_u[i_left_flat + j_top_flat],
params.n - 2, params.n - 2)
u_top_right_tile = af.moddims(flat_u[i_right_flat + j_top_flat],
params.n - 2, params.n - 2)
u_bottom_left_tile = af.moddims(flat_u[i_left_flat + j_bottom_flat],
params.n - 2, params.n - 2)
u_bottom_right_tile = af.moddims(flat_u[i_right_flat + j_bottom_flat],
params.n - 2, params.n - 2)
v_top_left_tile = af.moddims(flat_v[i_left_flat + j_top_flat],
params.n - 2, params.n - 2)
v_top_right_tile = af.moddims(flat_v[i_right_flat + j_top_flat],
params.n - 2, params.n - 2)
v_bottom_left_tile = af.moddims(flat_v[i_left_flat + j_bottom_flat],
params.n - 2, params.n - 2)
v_bottom_right_tile = af.moddims(flat_v[i_right_flat + j_bottom_flat],
params.n - 2, params.n - 2)
u_upper_tile = u_top_left_tile\
+ (u_top_right_tile - u_top_left_tile)\
* (x1_tile - x_left_tile) / params.delta_x
u_lower_tile = u_bottom_right_tile\
+ (u_bottom_left_tile - u_bottom_right_tile)\
* (x1_tile - x_left_tile) / params.delta_x
u_new_tile = u_lower_tile + (u_upper_tile - u_lower_tile)\
* (y1_tile - y_bottom_tile) / params.delta_x
v_upper_tile = v_top_left_tile + (v_top_right_tile - v_top_left_tile)\
* (x1_tile - x_left_tile) / params.delta_x
v_lower_tile = v_bottom_right_tile + (v_bottom_left_tile - v_bottom_right_tile)\
* (x1_tile - x_left_tile) / params.delta_x
v_new_tile = v_lower_tile + (v_upper_tile - v_lower_tile)\
* (y1_tile - y_bottom_tile) / params.delta_x
u_new = af.flat(u_new_tile)
v_new = af.flat(v_new_tile)
return u_new, v_new
