From 9e7cf4fcacb6c2c09e37fa61a9c4b90dc350817b Mon Sep 17 00:00:00 2001 From: abdul124 Date: Tue, 30 Jul 2024 18:10:38 +0800 Subject: [PATCH] np_reshape(WIP) and np_transpose added --- flake.nix | 2 + nac3core/src/codegen/numpy.rs | 387 ++++++++++++++++++++++++++ nac3core/src/toplevel/builtins.rs | 47 ++++ nac3core/src/toplevel/helper.rs | 6 + nac3standalone/demo/interpret_demo.py | 2 + nac3standalone/demo/interpreted.log | 10 + nac3standalone/demo/run_32.log | 10 + nac3standalone/demo/src/ndarray.py | 385 +++++++++++++------------ pyo3_output/nac3artiq.so | 1 + 9 files changed, 669 insertions(+), 181 deletions(-) create mode 100644 nac3standalone/demo/interpreted.log create mode 100644 nac3standalone/demo/run_32.log create mode 120000 pyo3_output/nac3artiq.so diff --git a/flake.nix b/flake.nix index d10bab12..f7f0d67d 100644 --- a/flake.nix +++ b/flake.nix @@ -161,7 +161,9 @@ clippy pre-commit rustfmt + rust-analyzer ]; + RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}"; }; devShells.x86_64-linux.msys2 = pkgs.mkShell { name = "nac3-dev-shell-msys2"; diff --git a/nac3core/src/codegen/numpy.rs b/nac3core/src/codegen/numpy.rs index a2b3c2c1..82ea77b4 100644 --- a/nac3core/src/codegen/numpy.rs +++ b/nac3core/src/codegen/numpy.rs @@ -2026,3 +2026,390 @@ pub fn gen_ndarray_fill<'ctx>( Ok(()) } + +pub fn ndarray_transpose<'ctx, G: CodeGenerator + ?Sized>( + generator: &mut G, + ctx: &mut CodeGenContext<'ctx, '_>, + x1: (Type, BasicValueEnum<'ctx>), +) -> Result, String> { + const FN_NAME: &str = "ndarray_transpose"; + let (x1_ty, x1) = x1; + let llvm_usize = generator.get_size_type(ctx.ctx); + + if let BasicValueEnum::PointerValue(n1) = x1 { + let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty); + let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None); + let n_sz = call_ndarray_calc_size(generator, ctx, &n1.dim_sizes(), (None, None)); + + let out = create_ndarray_dyn_shape( + generator, + ctx, + elem_ty, + &n1, + |_, ctx, n| Ok(n.load_ndims(ctx)), + |generator, ctx, n, idx| { + let new_idx = ctx.builder.build_int_sub(n.load_ndims(ctx), idx, "").unwrap(); + let new_idx = ctx + .builder + .build_int_sub(new_idx, new_idx.get_type().const_int(1, false), "") + .unwrap(); + unsafe { Ok(n.dim_sizes().get_typed_unchecked(ctx, generator, &new_idx, None)) } + }, + ) + .unwrap(); + + gen_for_callback_incrementing( + generator, + ctx, + None, + llvm_usize.const_zero(), + (n_sz, false), + |generator, ctx, _, idx| { + let elem = unsafe { n1.data().get_unchecked(ctx, generator, &idx, None) }; + // Calculate transposed idx + // 2, 3 => idx = row * num_col + col = 3 + 2 = 5 + // 2, 3, 4 => idx = row * (num_col*num_z) + col * (num_z) + z => 12 + 8 + 3 | 18, [4, 2] 15, ,1,2 + // num_z (col + num_col * row) + z + // 4D => 2, 3, 4, 5 = idx = num_w (num_z (col + num_col*row) + z) + w = 119 + // [1, 1, 2]? + // 4 (1 + 3*1) + 2 = 6 + // z = 2, col = 1, row = 0 + // 0,1, + // 2, 3 => idx = row * num_col + col | 2, 3, 4 => idx = row * (num_col * num_z) + col * (num_z) + num_z + // ND => idx = 1 * (dim0 + dim1 + ... dimn) + dim[-1] * (dim0 + dim1 + ... + dimn-1) + ... + dim[1] * dim0 + // 6 + 12 + 6 = 24 num_z * (row*num_col + col + 1) 4*6=24 + // 2, 3, 4, 5 at idx 1 should go to + // 5, 4, 3, 2 + + // 18 => [2, 4] dim = 4 + // 0 * 4 + 2 = 2 + // 4 => [1, 1] dim = 3 + // 2 * 3 + 1 + let new_idx = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?; + let rem_idx = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?; + ctx.builder.build_store(new_idx, llvm_usize.const_zero()).unwrap(); + ctx.builder.build_store(rem_idx, idx).unwrap(); + + gen_for_callback_incrementing( + generator, + ctx, + None, + llvm_usize.const_zero(), + (n1.load_ndims(ctx), false), + |generator, ctx, _, ndim| { + let ndim_rev = + ctx.builder.build_int_sub(n1.load_ndims(ctx), ndim, "").unwrap(); + let ndim_rev = ctx + .builder + .build_int_sub(ndim_rev, llvm_usize.const_int(1, false), "") + .unwrap(); + let dim = unsafe { + n1.dim_sizes().get_typed_unchecked(ctx, generator, &ndim_rev, None) + }; + + let rem_idx_val = + ctx.builder.build_load(rem_idx, "").unwrap().into_int_value(); + let new_idx_val = + ctx.builder.build_load(new_idx, "").unwrap().into_int_value(); + + let add_component = + ctx.builder.build_int_unsigned_rem(rem_idx_val, dim, "").unwrap(); + let rem_idx_val = + ctx.builder.build_int_unsigned_div(rem_idx_val, dim, "").unwrap(); + + let new_idx_val = ctx.builder.build_int_mul(new_idx_val, dim, "").unwrap(); + let new_idx_val = + ctx.builder.build_int_add(new_idx_val, add_component, "").unwrap(); + + ctx.builder.build_store(rem_idx, rem_idx_val).unwrap(); + ctx.builder.build_store(new_idx, new_idx_val).unwrap(); + + Ok(()) + }, + llvm_usize.const_int(1, false), + )?; + + let new_idx_val = ctx.builder.build_load(new_idx, "").unwrap().into_int_value(); + unsafe { out.data().set_unchecked(ctx, generator, &new_idx_val, elem) }; + Ok(()) + }, + llvm_usize.const_int(1, false), + )?; + + Ok(out.as_base_value().into()) + } else { + unreachable!( + "{FN_NAME}() not supported for '{}'", + format!("'{}'", ctx.unifier.stringify(x1_ty)) + ) + } +} + +pub fn ndarray_reshape<'ctx, G: CodeGenerator + ?Sized>( + generator: &mut G, + ctx: &mut CodeGenContext<'ctx, '_>, + x1: (Type, BasicValueEnum<'ctx>), + shape: (Type, BasicValueEnum<'ctx>), +) -> Result, String> { + const FN_NAME: &str = "ndarray_reshape"; + let (x1_ty, x1) = x1; + let (_, shape) = shape; + + let llvm_usize = generator.get_size_type(ctx.ctx); + + if let BasicValueEnum::PointerValue(n1) = x1 { + let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty); + let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None); + let n_sz = call_ndarray_calc_size(generator, ctx, &n1.dim_sizes(), (None, None)); + + // Check for -1 in the shapec + let ndim_ty = match shape { + BasicValueEnum::PointerValue(shape_list_ptr) + if ListValue::is_instance(shape_list_ptr, llvm_usize).is_ok() => + { + let shape_list = ListValue::from_ptr_val(shape_list_ptr, llvm_usize, None); + shape_list + .data() + .get(ctx, generator, &llvm_usize.const_zero(), None) + .into_int_value() + .get_type() + } + BasicValueEnum::StructValue(shape_tuple) => ctx + .builder + .build_extract_value(shape_tuple, 0, "") + .unwrap() + .into_int_value() + .get_type(), + BasicValueEnum::IntValue(shape_int) => shape_int.get_type(), + _ => unreachable!(), + }; + + let acc = generator.gen_var_alloc(ctx, ndim_ty.into(), None)?; + let num_neg = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?; + ctx.builder.build_store(acc, ndim_ty.const_int(1, false)).unwrap(); + ctx.builder.build_store(num_neg, llvm_usize.const_zero()).unwrap(); + + let out = match shape { + BasicValueEnum::PointerValue(shape_list_ptr) + if ListValue::is_instance(shape_list_ptr, llvm_usize).is_ok() => + { + let shape_list = ListValue::from_ptr_val(shape_list_ptr, llvm_usize, None); + gen_for_callback_incrementing( + generator, + ctx, + None, + llvm_usize.const_zero(), + (shape_list.load_size(ctx, None), false), + |generator, ctx, _, idx| { + let ele = + shape_list.data().get(ctx, generator, &idx, None).into_int_value(); + + gen_if_else_expr_callback( + generator, + ctx, + |_, ctx| { + Ok(ctx + .builder + .build_int_compare( + IntPredicate::SLT, + ele, + ndim_ty.const_zero(), + "", + ) + .unwrap()) + }, + |_, ctx| -> Result, String> { + let num_neg_value = + ctx.builder.build_load(num_neg, "").unwrap().into_int_value(); + let num_neg_value = ctx + .builder + .build_int_add( + num_neg_value, + llvm_usize.const_int(1, false), + "", + ) + .unwrap(); + ctx.builder.build_store(num_neg, num_neg_value).unwrap(); + Ok(None) + }, + |_, ctx| { + let acc_value = + ctx.builder.build_load(acc, "").unwrap().into_int_value(); + let acc_value = + ctx.builder.build_int_mul(acc_value, ele, "").unwrap(); + ctx.builder.build_store(acc, acc_value).unwrap(); + Ok(None) + }, + )?; + Ok(()) + }, + llvm_usize.const_int(1, false), + )?; + let acc_val = ctx.builder.build_load(acc, "").unwrap().into_int_value(); + let rem = ctx.builder.build_int_sub(n_sz, acc_val, "").unwrap(); + create_ndarray_dyn_shape( + generator, + ctx, + elem_ty, + &shape_list, + |_, ctx, _| Ok(shape_list.load_size(ctx, None)), + |generator, ctx, shape_list, idx| { + let dim = + shape_list.data().get(ctx, generator, &idx, None).into_int_value(); + Ok(gen_if_else_expr_callback( + generator, + ctx, + |_, ctx| { + Ok(ctx + .builder + .build_int_compare( + IntPredicate::SLT, + dim, + ndim_ty.const_zero(), + "", + ) + .unwrap()) + }, + |_, _| Ok(Some(rem)), + |_, _| Ok(Some(dim)), + )? + .unwrap() + .into_int_value()) + }, + ) + } + BasicValueEnum::StructValue(shape_tuple) => { + let ndims = shape_tuple.get_type().count_fields(); + let mut acc_val = ndim_ty.const_int(1, false); + + for dim_i in 0..ndims { + let dim = ctx + .builder + .build_extract_value(shape_tuple, dim_i, "") + .unwrap() + .into_int_value(); + + gen_if_else_expr_callback( + generator, + ctx, + |_, ctx| { + Ok(ctx + .builder + .build_int_compare(IntPredicate::SLT, dim, ndim_ty.const_zero(), "") + .unwrap()) + }, + |_, ctx| -> Result, String> { + let num_negs = + ctx.builder.build_load(num_neg, "").unwrap().into_int_value(); + let num_negs = ctx + .builder + .build_int_add(num_negs, llvm_usize.const_int(1, false), "") + .unwrap(); + ctx.builder.build_store(num_neg, num_negs).unwrap(); + Ok(None) + }, + |_, ctx| { + acc_val = ctx.builder.build_int_mul(acc_val, dim, "").unwrap(); + Ok(None) + }, + )?; + } + + let rem = ctx.builder.build_int_sub(n_sz, acc_val, "").unwrap(); + let mut shape = Vec::with_capacity(ndims as usize); + + for dim_i in 0..ndims { + let dim = ctx + .builder + .build_extract_value(shape_tuple, dim_i, "") + .unwrap() + .into_int_value(); + + let dim = gen_if_else_expr_callback( + generator, + ctx, + |_, ctx| { + Ok(ctx + .builder + .build_int_compare(IntPredicate::SLT, dim, ndim_ty.const_zero(), "") + .unwrap()) + }, + |_, _| Ok(Some(rem)), + |_, _| Ok(Some(dim)), + )? + .unwrap() + .into_int_value(); + shape.push(dim); + } + create_ndarray_const_shape(generator, ctx, elem_ty, shape.as_slice()) + } + BasicValueEnum::IntValue(shape_int) => { + let shape_int = gen_if_else_expr_callback( + generator, + ctx, + |_, ctx| { + Ok(ctx + .builder + .build_int_compare( + IntPredicate::SLT, + shape_int, + ndim_ty.const_zero(), + "", + ) + .unwrap()) + }, + |_, _| Ok(Some(n_sz)), + |_, _| Ok(Some(shape_int)), + )? + .unwrap() + .into_int_value(); + create_ndarray_const_shape(generator, ctx, elem_ty, &[shape_int]) + } + _ => unreachable!(), + } + .unwrap(); + + let num_negs = ctx.builder.build_load(num_neg, "").unwrap().into_int_value(); + ctx.make_assert( + generator, + ctx.builder + .build_int_compare(IntPredicate::ULT, num_negs, llvm_usize.const_int(2, false), "") + .unwrap(), + "0:ValueError", + "can only specify one unknown dimension", + [None, None, None], + ctx.current_loc, + ); + + let out_sz = call_ndarray_calc_size(generator, ctx, &out.dim_sizes(), (None, None)); + ctx.make_assert( + generator, + ctx.builder.build_int_compare(IntPredicate::EQ, out_sz, n_sz, "").unwrap(), + "0:ValueError", + "cannot reshape array of size {} into provided shape", + [Some(n_sz), None, None], + ctx.current_loc, + ); + + gen_for_callback_incrementing( + generator, + ctx, + None, + llvm_usize.const_zero(), + (n_sz, false), + |generator, ctx, _, idx| { + let elem = unsafe { n1.data().get_unchecked(ctx, generator, &idx, None) }; + unsafe { out.data().set_unchecked(ctx, generator, &idx, elem) }; + Ok(()) + }, + llvm_usize.const_int(1, false), + )?; + + Ok(out.as_base_value().into()) + } else { + unreachable!( + "{FN_NAME}() not supported for '{}'", + format!("'{}'", ctx.unifier.stringify(x1_ty)) + ) + } +} diff --git a/nac3core/src/toplevel/builtins.rs b/nac3core/src/toplevel/builtins.rs index 0d65828c..28197575 100644 --- a/nac3core/src/toplevel/builtins.rs +++ b/nac3core/src/toplevel/builtins.rs @@ -557,6 +557,10 @@ impl<'a> BuiltinBuilder<'a> { | PrimDef::FunNpHypot | PrimDef::FunNpNextAfter => self.build_np_2ary_function(prim), + PrimDef::FunNpTranspose | PrimDef::FunNpReshape => { + self.build_np_sp_ndarray_1ary_function(prim) + } + PrimDef::FunNpDot | PrimDef::FunNpLinalgMatmul | PrimDef::FunNpLinalgCholesky @@ -1885,6 +1889,49 @@ impl<'a> BuiltinBuilder<'a> { } } + /// Build 1-ary numpy/scipy functions that take in an ndarray and return a value of the same type as the input. + fn build_np_sp_ndarray_1ary_function(&mut self, prim: PrimDef) -> TopLevelDef { + debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpTranspose, PrimDef::FunNpReshape]); + + let elem_type = self.unifier.get_fresh_var(Some("R".into()), None); + let ndarray_type = make_ndarray_ty(self.unifier, self.primitives, Some(elem_type.ty), None); + let ndarray_ty = + self.unifier.get_fresh_var_with_range(&[ndarray_type], Some("T".into()), None); + let var_map = into_var_map([elem_type, ndarray_ty]); + + match prim { + PrimDef::FunNpTranspose => create_fn_by_codegen( + self.unifier, + &var_map, + prim.name(), + ndarray_ty.ty, + &[(ndarray_ty.ty, "x")], + Box::new(move |ctx, _, fun, args, generator| { + let arg_ty = fun.0.args[0].ty; + let arg_val = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?; + Ok(Some(ndarray_transpose(generator, ctx, (arg_ty, arg_val))?)) + }), + ), + + PrimDef::FunNpReshape => create_fn_by_codegen( + self.unifier, + &var_map, + prim.name(), + ndarray_ty.ty, + &[(ndarray_ty.ty, "x"), (self.ndarray_factory_fn_shape_arg_tvar.ty, "shape")], + Box::new(move |ctx, _, fun, args, generator| { + let x1_ty = fun.0.args[0].ty; + let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?; + let x2_ty = fun.0.args[1].ty; + let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?; + Ok(Some(ndarray_reshape(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?)) + }), + ), + + _ => unreachable!(), + } + } + /// Build `np_linalg` and `sp_linalg` functions /// /// The input to these functions must be floating point `NDArray` diff --git a/nac3core/src/toplevel/helper.rs b/nac3core/src/toplevel/helper.rs index 50deabca..ae17e62c 100644 --- a/nac3core/src/toplevel/helper.rs +++ b/nac3core/src/toplevel/helper.rs @@ -99,6 +99,8 @@ pub enum PrimDef { FunNpLdExp, FunNpHypot, FunNpNextAfter, + FunNpTranspose, + FunNpReshape, // Linalg functions FunNpDot, @@ -282,6 +284,10 @@ impl PrimDef { PrimDef::FunNpLdExp => fun("np_ldexp", None), PrimDef::FunNpHypot => fun("np_hypot", None), PrimDef::FunNpNextAfter => fun("np_nextafter", None), + PrimDef::FunNpTranspose => fun("np_transpose", None), + PrimDef::FunNpReshape => fun("np_reshape", None), + + // Linalg functions PrimDef::FunNpDot => fun("np_dot", None), PrimDef::FunNpLinalgMatmul => fun("np_linalg_matmul", None), PrimDef::FunNpLinalgCholesky => fun("np_linalg_cholesky", None), diff --git a/nac3standalone/demo/interpret_demo.py b/nac3standalone/demo/interpret_demo.py index 379fb349..cb9693ff 100755 --- a/nac3standalone/demo/interpret_demo.py +++ b/nac3standalone/demo/interpret_demo.py @@ -218,6 +218,8 @@ def patch(module): module.np_ldexp = np.ldexp module.np_hypot = np.hypot module.np_nextafter = np.nextafter + module.np_transpose = np.transpose + module.np_reshape = np.reshape # SciPy Math functions module.sp_spec_erf = special.erf diff --git a/nac3standalone/demo/interpreted.log b/nac3standalone/demo/interpreted.log new file mode 100644 index 00000000..e169dd39 --- /dev/null +++ b/nac3standalone/demo/interpreted.log @@ -0,0 +1,10 @@ +1.000000 +2.000000 +3.000000 +4.000000 +5.000000 +6.000000 +7.000000 +8.000000 +9.000000 +10.000000 diff --git a/nac3standalone/demo/run_32.log b/nac3standalone/demo/run_32.log new file mode 100644 index 00000000..e169dd39 --- /dev/null +++ b/nac3standalone/demo/run_32.log @@ -0,0 +1,10 @@ +1.000000 +2.000000 +3.000000 +4.000000 +5.000000 +6.000000 +7.000000 +8.000000 +9.000000 +10.000000 diff --git a/nac3standalone/demo/src/ndarray.py b/nac3standalone/demo/src/ndarray.py index 9899cf17..fdd4e046 100644 --- a/nac3standalone/demo/src/ndarray.py +++ b/nac3standalone/demo/src/ndarray.py @@ -68,6 +68,12 @@ def output_ndarray_float_2(n: ndarray[float, Literal[2]]): for c in range(len(n[r])): output_float64(n[r][c]) +def output_ndarray_float_3(n: ndarray[float, Literal[3]]): + for r in range(len(n)): + for c in range(len(n[r])): + for z in range(len(n[r][c])): + output_float64(n[r][c][z]) + def consume_ndarray_1(n: ndarray[float, Literal[1]]): pass @@ -1429,6 +1435,21 @@ def test_ndarray_nextafter_broadcast_rhs_scalar(): output_ndarray_float_2(nextafter_x_zeros) output_ndarray_float_2(nextafter_x_ones) +def test_ndarray_transpose(): + # x: ndarray[float, 3] = np_array([[[1., 2.], [3., 4.], [5., 6.]]]) + x: ndarray[float, 1] = np_array([1., 2., 3.]) + y = np_transpose(x) + + output_ndarray_float_1(x) + output_ndarray_float_1(y) + +def test_ndarray_reshape(): + x: ndarray[float, 1] = np_array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) + y = np_reshape(x, [2, 5]) + + output_ndarray_float_1(x) + # output_ndarray_float_1(y) + def test_ndarray_dot(): x: ndarray[float, 1] = np_array([5.0, 1.0]) y: ndarray[float, 1] = np_array([5.0, 1.0]) @@ -1528,192 +1549,194 @@ def test_ndarray_svd(): def run() -> int32: - test_ndarray_ctor() - test_ndarray_empty() - test_ndarray_zeros() - test_ndarray_ones() - test_ndarray_full() - test_ndarray_eye() - test_ndarray_array() - test_ndarray_identity() - test_ndarray_fill() - test_ndarray_copy() + # test_ndarray_ctor() + # test_ndarray_empty() + # test_ndarray_zeros() + # test_ndarray_ones() + # test_ndarray_full() + # test_ndarray_eye() + # test_ndarray_array() + # test_ndarray_identity() + # test_ndarray_fill() + # test_ndarray_copy() - test_ndarray_neg_idx() - test_ndarray_slices() - test_ndarray_nd_idx() + # test_ndarray_neg_idx() + # test_ndarray_slices() + # test_ndarray_nd_idx() - test_ndarray_add() - test_ndarray_add_broadcast() - test_ndarray_add_broadcast_lhs_scalar() - test_ndarray_add_broadcast_rhs_scalar() - test_ndarray_iadd() - test_ndarray_iadd_broadcast() - test_ndarray_iadd_broadcast_scalar() - test_ndarray_sub() - test_ndarray_sub_broadcast() - test_ndarray_sub_broadcast_lhs_scalar() - test_ndarray_sub_broadcast_rhs_scalar() - test_ndarray_isub() - test_ndarray_isub_broadcast() - test_ndarray_isub_broadcast_scalar() - test_ndarray_mul() - test_ndarray_mul_broadcast() - test_ndarray_mul_broadcast_lhs_scalar() - test_ndarray_mul_broadcast_rhs_scalar() - test_ndarray_imul() - test_ndarray_imul_broadcast() - test_ndarray_imul_broadcast_scalar() - test_ndarray_truediv() - test_ndarray_truediv_broadcast() - test_ndarray_truediv_broadcast_lhs_scalar() - test_ndarray_truediv_broadcast_rhs_scalar() - test_ndarray_itruediv() - test_ndarray_itruediv_broadcast() - test_ndarray_itruediv_broadcast_scalar() - test_ndarray_floordiv() - test_ndarray_floordiv_broadcast() - test_ndarray_floordiv_broadcast_lhs_scalar() - test_ndarray_floordiv_broadcast_rhs_scalar() - test_ndarray_ifloordiv() - test_ndarray_ifloordiv_broadcast() - test_ndarray_ifloordiv_broadcast_scalar() - test_ndarray_mod() - test_ndarray_mod_broadcast() - test_ndarray_mod_broadcast_lhs_scalar() - test_ndarray_mod_broadcast_rhs_scalar() - test_ndarray_imod() - test_ndarray_imod_broadcast() - test_ndarray_imod_broadcast_scalar() - test_ndarray_pow() - test_ndarray_pow_broadcast() - test_ndarray_pow_broadcast_lhs_scalar() - test_ndarray_pow_broadcast_rhs_scalar() - test_ndarray_ipow() - test_ndarray_ipow_broadcast() - test_ndarray_ipow_broadcast_scalar() - test_ndarray_matmul() - test_ndarray_imatmul() - test_ndarray_pos() - test_ndarray_neg() - test_ndarray_inv() - test_ndarray_eq() - test_ndarray_eq_broadcast() - test_ndarray_eq_broadcast_lhs_scalar() - test_ndarray_eq_broadcast_rhs_scalar() - test_ndarray_ne() - test_ndarray_ne_broadcast() - test_ndarray_ne_broadcast_lhs_scalar() - test_ndarray_ne_broadcast_rhs_scalar() - test_ndarray_lt() - test_ndarray_lt_broadcast() - test_ndarray_lt_broadcast_lhs_scalar() - test_ndarray_lt_broadcast_rhs_scalar() - test_ndarray_lt() - test_ndarray_le_broadcast() - test_ndarray_le_broadcast_lhs_scalar() - test_ndarray_le_broadcast_rhs_scalar() - test_ndarray_gt() - test_ndarray_gt_broadcast() - test_ndarray_gt_broadcast_lhs_scalar() - test_ndarray_gt_broadcast_rhs_scalar() - test_ndarray_gt() - test_ndarray_ge_broadcast() - test_ndarray_ge_broadcast_lhs_scalar() - test_ndarray_ge_broadcast_rhs_scalar() + # test_ndarray_add() + # test_ndarray_add_broadcast() + # test_ndarray_add_broadcast_lhs_scalar() + # test_ndarray_add_broadcast_rhs_scalar() + # test_ndarray_iadd() + # test_ndarray_iadd_broadcast() + # test_ndarray_iadd_broadcast_scalar() + # test_ndarray_sub() + # test_ndarray_sub_broadcast() + # test_ndarray_sub_broadcast_lhs_scalar() + # test_ndarray_sub_broadcast_rhs_scalar() + # test_ndarray_isub() + # test_ndarray_isub_broadcast() + # test_ndarray_isub_broadcast_scalar() + # test_ndarray_mul() + # test_ndarray_mul_broadcast() + # test_ndarray_mul_broadcast_lhs_scalar() + # test_ndarray_mul_broadcast_rhs_scalar() + # test_ndarray_imul() + # test_ndarray_imul_broadcast() + # test_ndarray_imul_broadcast_scalar() + # test_ndarray_truediv() + # test_ndarray_truediv_broadcast() + # test_ndarray_truediv_broadcast_lhs_scalar() + # test_ndarray_truediv_broadcast_rhs_scalar() + # test_ndarray_itruediv() + # test_ndarray_itruediv_broadcast() + # test_ndarray_itruediv_broadcast_scalar() + # test_ndarray_floordiv() + # test_ndarray_floordiv_broadcast() + # test_ndarray_floordiv_broadcast_lhs_scalar() + # test_ndarray_floordiv_broadcast_rhs_scalar() + # test_ndarray_ifloordiv() + # test_ndarray_ifloordiv_broadcast() + # test_ndarray_ifloordiv_broadcast_scalar() + # test_ndarray_mod() + # test_ndarray_mod_broadcast() + # test_ndarray_mod_broadcast_lhs_scalar() + # test_ndarray_mod_broadcast_rhs_scalar() + # test_ndarray_imod() + # test_ndarray_imod_broadcast() + # test_ndarray_imod_broadcast_scalar() + # test_ndarray_pow() + # test_ndarray_pow_broadcast() + # test_ndarray_pow_broadcast_lhs_scalar() + # test_ndarray_pow_broadcast_rhs_scalar() + # test_ndarray_ipow() + # test_ndarray_ipow_broadcast() + # test_ndarray_ipow_broadcast_scalar() + # test_ndarray_matmul() + # test_ndarray_imatmul() + # test_ndarray_pos() + # test_ndarray_neg() + # test_ndarray_inv() + # test_ndarray_eq() + # test_ndarray_eq_broadcast() + # test_ndarray_eq_broadcast_lhs_scalar() + # test_ndarray_eq_broadcast_rhs_scalar() + # test_ndarray_ne() + # test_ndarray_ne_broadcast() + # test_ndarray_ne_broadcast_lhs_scalar() + # test_ndarray_ne_broadcast_rhs_scalar() + # test_ndarray_lt() + # test_ndarray_lt_broadcast() + # test_ndarray_lt_broadcast_lhs_scalar() + # test_ndarray_lt_broadcast_rhs_scalar() + # test_ndarray_lt() + # test_ndarray_le_broadcast() + # test_ndarray_le_broadcast_lhs_scalar() + # test_ndarray_le_broadcast_rhs_scalar() + # test_ndarray_gt() + # test_ndarray_gt_broadcast() + # test_ndarray_gt_broadcast_lhs_scalar() + # test_ndarray_gt_broadcast_rhs_scalar() + # test_ndarray_gt() + # test_ndarray_ge_broadcast() + # test_ndarray_ge_broadcast_lhs_scalar() + # test_ndarray_ge_broadcast_rhs_scalar() - test_ndarray_int32() - test_ndarray_int64() - test_ndarray_uint32() - test_ndarray_uint64() - test_ndarray_float() - test_ndarray_bool() + # test_ndarray_int32() + # test_ndarray_int64() + # test_ndarray_uint32() + # test_ndarray_uint64() + # test_ndarray_float() + # test_ndarray_bool() - test_ndarray_round() - test_ndarray_floor() - test_ndarray_min() - test_ndarray_minimum() - test_ndarray_minimum_broadcast() - test_ndarray_minimum_broadcast_lhs_scalar() - test_ndarray_minimum_broadcast_rhs_scalar() - test_ndarray_argmin() - test_ndarray_max() - test_ndarray_maximum() - test_ndarray_maximum_broadcast() - test_ndarray_maximum_broadcast_lhs_scalar() - test_ndarray_maximum_broadcast_rhs_scalar() - test_ndarray_argmax() - test_ndarray_abs() - test_ndarray_isnan() - test_ndarray_isinf() + # test_ndarray_round() + # test_ndarray_floor() + # test_ndarray_min() + # test_ndarray_minimum() + # test_ndarray_minimum_broadcast() + # test_ndarray_minimum_broadcast_lhs_scalar() + # test_ndarray_minimum_broadcast_rhs_scalar() + # test_ndarray_argmin() + # test_ndarray_max() + # test_ndarray_maximum() + # test_ndarray_maximum_broadcast() + # test_ndarray_maximum_broadcast_lhs_scalar() + # test_ndarray_maximum_broadcast_rhs_scalar() + # test_ndarray_argmax() + # test_ndarray_abs() + # test_ndarray_isnan() + # test_ndarray_isinf() - test_ndarray_sin() - test_ndarray_cos() - test_ndarray_exp() - test_ndarray_exp2() - test_ndarray_log() - test_ndarray_log10() - test_ndarray_log2() - test_ndarray_fabs() - test_ndarray_sqrt() - test_ndarray_rint() - test_ndarray_tan() - test_ndarray_arcsin() - test_ndarray_arccos() - test_ndarray_arctan() - test_ndarray_sinh() - test_ndarray_cosh() - test_ndarray_tanh() - test_ndarray_arcsinh() - test_ndarray_arccosh() - test_ndarray_arctanh() - test_ndarray_expm1() - test_ndarray_cbrt() + # test_ndarray_sin() + # test_ndarray_cos() + # test_ndarray_exp() + # test_ndarray_exp2() + # test_ndarray_log() + # test_ndarray_log10() + # test_ndarray_log2() + # test_ndarray_fabs() + # test_ndarray_sqrt() + # test_ndarray_rint() + # test_ndarray_tan() + # test_ndarray_arcsin() + # test_ndarray_arccos() + # test_ndarray_arctan() + # test_ndarray_sinh() + # test_ndarray_cosh() + # test_ndarray_tanh() + # test_ndarray_arcsinh() + # test_ndarray_arccosh() + # test_ndarray_arctanh() + # test_ndarray_expm1() + # test_ndarray_cbrt() - test_ndarray_erf() - test_ndarray_erfc() - test_ndarray_gamma() - test_ndarray_gammaln() - test_ndarray_j0() - test_ndarray_j1() + # test_ndarray_erf() + # test_ndarray_erfc() + # test_ndarray_gamma() + # test_ndarray_gammaln() + # test_ndarray_j0() + # test_ndarray_j1() - test_ndarray_arctan2() - test_ndarray_arctan2_broadcast() - test_ndarray_arctan2_broadcast_lhs_scalar() - test_ndarray_arctan2_broadcast_rhs_scalar() - test_ndarray_copysign() - test_ndarray_copysign_broadcast() - test_ndarray_copysign_broadcast_lhs_scalar() - test_ndarray_copysign_broadcast_rhs_scalar() - test_ndarray_fmax() - test_ndarray_fmax_broadcast() - test_ndarray_fmax_broadcast_lhs_scalar() - test_ndarray_fmax_broadcast_rhs_scalar() - test_ndarray_fmin() - test_ndarray_fmin_broadcast() - test_ndarray_fmin_broadcast_lhs_scalar() - test_ndarray_fmin_broadcast_rhs_scalar() - test_ndarray_ldexp() - test_ndarray_ldexp_broadcast() - test_ndarray_ldexp_broadcast_lhs_scalar() - test_ndarray_ldexp_broadcast_rhs_scalar() - test_ndarray_hypot() - test_ndarray_hypot_broadcast() - test_ndarray_hypot_broadcast_lhs_scalar() - test_ndarray_hypot_broadcast_rhs_scalar() - test_ndarray_nextafter() - test_ndarray_nextafter_broadcast() - test_ndarray_nextafter_broadcast_lhs_scalar() - test_ndarray_nextafter_broadcast_rhs_scalar() - - test_ndarray_dot() - test_ndarray_linalg_matmul() - test_ndarray_cholesky() - test_ndarray_qr() - test_ndarray_svd() - test_ndarray_linalg_inv() - test_ndarray_pinv() - test_ndarray_lu() - test_ndarray_schur() - test_ndarray_hessenberg() + # test_ndarray_arctan2() + # test_ndarray_arctan2_broadcast() + # test_ndarray_arctan2_broadcast_lhs_scalar() + # test_ndarray_arctan2_broadcast_rhs_scalar() + # test_ndarray_copysign() + # test_ndarray_copysign_broadcast() + # test_ndarray_copysign_broadcast_lhs_scalar() + # test_ndarray_copysign_broadcast_rhs_scalar() + # test_ndarray_fmax() + # test_ndarray_fmax_broadcast() + # test_ndarray_fmax_broadcast_lhs_scalar() + # test_ndarray_fmax_broadcast_rhs_scalar() + # test_ndarray_fmin() + # test_ndarray_fmin_broadcast() + # test_ndarray_fmin_broadcast_lhs_scalar() + # test_ndarray_fmin_broadcast_rhs_scalar() + # test_ndarray_ldexp() + # test_ndarray_ldexp_broadcast() + # test_ndarray_ldexp_broadcast_lhs_scalar() + # test_ndarray_ldexp_broadcast_rhs_scalar() + # test_ndarray_hypot() + # test_ndarray_hypot_broadcast() + # test_ndarray_hypot_broadcast_lhs_scalar() + # test_ndarray_hypot_broadcast_rhs_scalar() + # test_ndarray_nextafter() + # test_ndarray_nextafter_broadcast() + # test_ndarray_nextafter_broadcast_lhs_scalar() + # test_ndarray_nextafter_broadcast_rhs_scalar() + # test_ndarray_transpose() + test_ndarray_reshape() + + # test_ndarray_dot() + # test_ndarray_linalg_matmul() + # test_ndarray_cholesky() + # test_ndarray_qr() + # test_ndarray_svd() + # test_ndarray_linalg_inv() + # test_ndarray_pinv() + # test_ndarray_lu() + # test_ndarray_schur() + # test_ndarray_hessenberg() return 0 diff --git a/pyo3_output/nac3artiq.so b/pyo3_output/nac3artiq.so new file mode 120000 index 00000000..cd55226d --- /dev/null +++ b/pyo3_output/nac3artiq.so @@ -0,0 +1 @@ +../target/debug/libnac3artiq.so \ No newline at end of file