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");