def initialize_B(q1, q2, params):
B1 = -(1 / np.sqrt(4 * np.pi)) * af.sin(2 * np.pi * q2)
B2 = (1 / np.sqrt(4 * np.pi)) * af.sin(4 * np.pi * q1)
B3 = 0 * q1**0
return (B1, B2, B3)
def test_compute_electrostatic_fields():
test_obj = test()
compute_electrostatic_fields(test_obj)
E1 = 0.5 * test_obj.N_q1 * test_obj.N_q2 * af.ifft2(test_obj.E1_hat)
E2 = 0.5 * test_obj.N_q1 * test_obj.N_q2 * af.ifft2(test_obj.E2_hat)
E1_analytical = test_obj.physical_system.params.charge_electron \
* 2 * np.pi / (20 * np.pi**2) \
* ( 0.01 * af.sin(2 * np.pi * test_obj.q1 + 4 * np.pi * test_obj.q2)
+ 0.02 * af.cos(2 * np.pi * test_obj.q1 + 4 * np.pi * test_obj.q2)
)
E2_analytical = test_obj.physical_system.params.charge_electron \
* 4 * np.pi / (20 * np.pi**2) \
* ( 0.01 * af.sin(2 * np.pi * test_obj.q1 + 4 * np.pi * test_obj.q2)
+ 0.02 * af.cos(2 * np.pi * test_obj.q1 + 4 * np.pi * test_obj.q2)
)
add = lambda a,b:a+b
error_E1 = af.mean(af.abs(af.broadcast(add, E1_analytical, - E1)))
error_E2 = af.mean(af.abs(af.broadcast(add, E2_analytical, - E2)))
assert(error_E1 < 1e-14)
assert(error_E2 < 1e-14)
def initialize_f(q1, q2, v1, v2, v3, params):
m = params.mass
k = params.boltzmann_constant
n_b = params.density_background
T_b = params.temperature_background
k = params.boltzmann_constant
v1_bulk = 0
# Assigning separate bulk velocities
v2_bulk = params.amplitude * -1.7450858652952794e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.5123323181646575 * af.sin(params.k_q1 * q1)
v3_bulk = params.amplitude * 0.5123323181646597 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
n = n_b + 0 * q1**0
f = n * (m / (2 * np.pi * k * T_b)) \
* af.exp(-m * (v2 - v2_bulk)**2 / (2 * k * T_b)) \
* af.exp(-m * (v3 - v3_bulk)**2 / (2 * k * T_b))
af.eval(f)
return (f)
def initialize_f(r, theta, rdot, thetadot, phidot, params):
# Using a transformation to get the coordinates in the form used in regular cartesian coordinates:
q1 = r * af.cos(theta)
q2 = r * af.sin(theta)
p1 = rdot * af.cos(theta) - r * af.sin(theta) * thetadot
p2 = rdot * af.sin(theta) + r * af.cos(theta) * thetadot
q10 = params.q10
q20 = params.q20
p10 = params.p10
p20 = params.p20
sigma_q = params.sigma_q
sigma_p = params.sigma_p
q_profile = (1 / sigma_q**2 / (2 * np.pi)) * \
af.exp(-0.5 * ((q1 - q10)**2 + (q2 - q20)**2) / sigma_q**2)
p_profile = (1 / sigma_p**2 / (2 * np.pi)) * \
af.exp(-0.5 * ((p1 - p10)**2 + (p2 - p20)**2) / sigma_p**2)
f = q_profile * p_profile
af.eval(f)
return (f)
def initialize_f(q1, q2, v1, v2, v3, params):
m = params.mass
k = params.boltzmann_constant
n_b = params.density_background
T_b = params.temperature_background
v1_bulk_b = params.v1_bulk_background
v2_bulk_b = params.v2_bulk_background
v3_bulk_b = params.v3_bulk_background
pert_real_n = 1
pert_imag_n = 0
pert_real_v1 = -np.sqrt(params.gamma * T_b) / n_b \
* params.k_q1 / np.sqrt(params.k_q1**2 + params.k_q2**2) * 1j
pert_imag_v1 = 0
pert_real_v2 = -np.sqrt(params.gamma * T_b) / n_b \
* params.k_q2 / np.sqrt(params.k_q1**2 + params.k_q2**2) * 1j
pert_imag_v2 = 0
pert_real_T = T_b * (params.gamma - 1) / n_b
pert_imag_T = 0
k_q1 = params.k_q1
k_q2 = params.k_q2
amp = params.amplitude
# Introducing the perturbation amounts:
# This is obtained from the Sage Worksheet(https://goo.gl/Sh8Nqt):
# Plugging in the value from the Eigenvectors:
# Calculating the perturbed density:
n = n_b + amp * (pert_real_n * af.cos(k_q1 * q1 + k_q2 * q2) -
pert_imag_n * af.sin(k_q1 * q1 + k_q2 * q2))
# Calculating the perturbed bulk velocities:
v1_bulk = v1_bulk_b + amp * (pert_real_v1 * af.cos(k_q1 * q1 + k_q2 * q2) -
pert_imag_v1 * af.sin(k_q1 * q1 + k_q2 * q2))
v2_bulk = v2_bulk_b + amp * (pert_real_v2 * af.cos(k_q1 * q1 + k_q2 * q2) -
pert_imag_v2 * af.sin(k_q1 * q1 + k_q2 * q2))
v3_bulk = v3_bulk_b
# Calculating the perturbed temperature:
T = T_b + amp * (pert_real_T * af.cos(k_q1 * q1 + k_q2 * q2) -
pert_imag_T * af.sin(k_q1 * q1 + k_q2 * q2))
f = n * (m / (2 * np.pi * k * T))**(3 / 2) \
* af.exp(-m * (v1 - v1_bulk)**2 / (2 * k * T)) \
* af.exp(-m * (v2 - v2_bulk)**2 / (2 * k * T)) \
* af.exp(-m * (v3 - v3_bulk)**2 / (2 * k * T))
af.eval(f)
return (f)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * -0.3879300732291651 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.38793007322916484 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.2254761533604373 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.2254761533604362 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.06556382361214784 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.06556382361214708 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.4015946538685527 * af.cos(params.k_q1 * q1) \
- params.amplitude * 7.787402806072119e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -6.297775989619429e-16 * af.cos(params.k_q1 * q1) \
- params.amplitude * - 0.40159465386855214 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * -0.3794960354426652 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.3794960354426654 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.11095238911208773 * af.cos(params.k_q1 * q1) \
- params.amplitude * 4.996003610813204e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -4.7878367936959876e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.11095238911208799 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.19890202265731305 * af.cos(params.k_q1 * q1) \
- params.amplitude * 1.1709383462843448e-17 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -6.297775989619429e-16 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.19890202265731322 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.37543492280290924 * af.cos(params.k_q1 * q1) \
- params.amplitude * - 1.2624517859056994e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -1.0524486013588352e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * -0.37543492280290663 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.2537386046535821 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.25373860465358244 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.08198343373747802 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.08198343373747803 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.2825628831308188 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.28256288313081546 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.10423537046121174 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.10423537046121167 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.07316088265835553 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.07316088265835408 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.32206272786511525 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.3220627278651147 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.39468140164821774 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * - 0.39468140164821736 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0.35795776606370105 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.3579577660636656 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.38824299607278767 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * - 0.38824299607278534 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return(E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.13444732969430967 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.1344473296943089 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -1.3292186285774276e-16 * af.cos(params.k_q1 * q1) \
- params.amplitude * - 0.40083580763931476 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.40083580763931453 * af.cos(params.k_q1 * q1) \
- params.amplitude * + 2.0159591932422221e-16 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * -0.35882311416315243 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.35882311416315205 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.1182028475640979 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.1182028475640971 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.09225609651339009 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.0922560965133902 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * 0 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.17471769676500346 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * 0.17471769676500315 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.15322895762201727 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * 0.15322895762201585 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
def initialize_E(q1, q2, params):
E1 = 0 * q1**0
E2 = params.amplitude * -0.34711374021236485 * af.cos(params.k_q1 * q1) \
- params.amplitude * -1.1102230246251565e-16 * af.sin(params.k_q1 * q1)
E3 = params.amplitude * -5.578870698741412e-15 * af.cos(params.k_q1 * q1) \
- params.amplitude * -0.3471137402123639 * af.sin(params.k_q1 * q1)
af.eval(E1, E2, E3)
return (E1, E2, E3)
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))
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)) af.display(af.tan(a)) af.display(af.asin(a)) af.display(af.acos(a)) af.display(af.atan(a)) af.display(af.atan2(a, b)) c = af.cplx(a) d = af.cplx(a,b) af.display(c) af.display(d) af.display(af.real(d)) af.display(af.imag(d)) af.display(af.conjg(d))
# 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
def sin(x):
if isinstance(x, afnumpy.ndarray):
s = arrayfire.sin(x.d_array)
return afnumpy.ndarray(x.shape, dtype=pu.typemap(s.dtype()), af_array=s)
else:
return numpy.sin(x)
#!/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.info()
POINTS = 30
N = 2 * POINTS
x = (af.iota(d0 = N, d1 = 1, tile_dims = (1, N)) - POINTS) / POINTS
y = (af.iota(d0 = 1, d1 = N, tile_dims = (N, 1)) - POINTS) / POINTS
win = af.Window(800, 800, "3D Surface example using ArrayFire")
t = 0
while not win.close():
t = t + 0.07
z = 10*x*-af.abs(y) * af.cos(x*x*(y+t))+af.sin(y*(x+t))-1.5;
win.surface(x, y, z)
# 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 math
POINTS = 10000
PRECISION = 1.0 / float(POINTS)
val = -math.pi
X = math.pi * (2 * (af.range(POINTS) / POINTS) - 1)
win = af.window(512, 512, "2D Plot example using ArrayFire")
sign = 1.0
while not win.close():
Y = af.sin(X)
win.plot(X, Y)
X += PRECISION * sign
val += PRECISION * sign
if (val > math.pi):
sign = -1.0
elif (val < -math.pi):
sign = 1.0
# 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,:];
af.display(c);
print("Scan Test\n");
