file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
tests/nodes/argmin_fp8x23_2D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 100663296, sign: false });
data.append(FP8x23 { mag: 436207616, sign: true });
data.append(FP8x23 { mag: 897581056, sign: false });
data.append(FP8x23 { mag: 847249408, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_2D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_2D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp8x23_2D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_2D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 520093696, sign: false });
data.append(FP8x23 { mag: 444596224, sign: false });
data.append(FP8x23 { mag: 637534208, sign: false });
data.append(FP8x23 { mag: 729808896, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_2D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_2D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp8x23_2D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_2D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 536870912, sign: false });
data.append(FP8x23 { mag: 947912704, sign: false });
data.append(FP8x23 { mag: 998244352, sign: false });
data.append(FP8x23 { mag: 1056964608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_2D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp8x23_3D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 981467136, sign: true });
data.append(FP8x23 { mag: 914358272, sign: false });
data.append(FP8x23 { mag: 662700032, sign: true });
data.append(FP8x23 { mag: 58720256, sign: false });
data.append(FP8x23 { mag: 176160768, sign: false });
data.append(FP8x23 { mag: 905969664, sign: true });
data.append(FP8x23 { mag: 486539264, sign: true });
data.append(FP8x23 { mag: 838860800, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp8x23_3D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 251658240, sign: true });
data.append(FP8x23 { mag: 864026624, sign: false });
data.append(FP8x23 { mag: 1006632960, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 889192448, sign: true });
data.append(FP8x23 { mag: 243269632, sign: false });
data.append(FP8x23 { mag: 402653184, sign: false });
data.append(FP8x23 { mag: 822083584, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp8x23_3D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1065353216, sign: true });
data.append(FP8x23 { mag: 352321536, sign: true });
data.append(FP8x23 { mag: 486539264, sign: false });
data.append(FP8x23 { mag: 301989888, sign: false });
data.append(FP8x23 { mag: 847249408, sign: true });
data.append(FP8x23 { mag: 696254464, sign: true });
data.append(FP8x23 { mag: 545259520, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_3D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_1D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-34);
data.append(-47);
data.append(-23);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_1D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(73);
data.append(75);
data.append(-3);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_1D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(165);
data.append(215);
data.append(188);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_1D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_2D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(77);
data.append(3);
data.append(99);
data.append(-44);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_2D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(97);
data.append(-75);
data.append(27);
data.append(36);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_2D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-46);
data.append(39);
data.append(-26);
data.append(56);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_2D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_3D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-71);
data.append(99);
data.append(106);
data.append(-4);
data.append(-110);
data.append(56);
data.append(-77);
data.append(-6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_3D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-24);
data.append(-16);
data.append(-113);
data.append(-11);
data.append(-67);
data.append(53);
data.append(65);
data.append(29);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i32_3D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-120);
data.append(122);
data.append(-75);
data.append(123);
data.append(-48);
data.append(-96);
data.append(-113);
data.append(59);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i32_3D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_1D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-122);
data.append(48);
data.append(12);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_1D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-102);
data.append(94);
data.append(122);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_1D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-126);
data.append(-114);
data.append(-119);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_1D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_2D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-5);
data.append(96);
data.append(-59);
data.append(-110);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_2D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-91);
data.append(-120);
data.append(62);
data.append(-4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_2D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(90);
data.append(-107);
data.append(11);
data.append(77);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_2D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_3D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(104);
data.append(91);
data.append(-75);
data.append(51);
data.append(-57);
data.append(-22);
data.append(-13);
data.append(72);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_3D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-7);
data.append(-74);
data.append(93);
data.append(-43);
data.append(77);
data.append(-8);
data.append(39);
data.append(-121);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_i8_3D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-73);
data.append(-96);
data.append(-90);
data.append(9);
data.append(-99);
data.append(-18);
data.append(-49);
data.append(-30);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_i8_3D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_1D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(247);
data.append(56);
data.append(43);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_1D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(48);
data.append(249);
data.append(180);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_1D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(196);
data.append(188);
data.append(28);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_1D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_2D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(85);
data.append(201);
data.append(161);
data.append(249);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_2D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(242);
data.append(21);
data.append(196);
data.append(65);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_2D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(95);
data.append(155);
data.append(175);
data.append(231);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_2D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_default.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_3D_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(132);
data.append(217);
data.append(50);
data.append(22);
data.append(79);
data.append(215);
data.append(166);
data.append(125);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_keepdims_false.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_3D_keepdims_false() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::Some(false), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_keepdims_false/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(133);
data.append(237);
data.append(19);
data.append(140);
data.append(162);
data.append(214);
data.append(247);
data.append(234);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_keepdims_false/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_last_index.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_u32_3D_last_index() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.argmin(0, Option::None(()), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_last_index/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(21);
data.append(206);
data.append(245);
data.append(180);
data.append(229);
data.append(107);
data.append(167);
data.append(193);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_u32_3D_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/array_feature_extractor_1D_fp16x16.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_array_feature_extractor_1D_fp16x16() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = TensorTrait::array_feature_extractor(@input_0, input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/array_feature_extractor_1D_fp16x16/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |