file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
tests/nodes/add_fp8x23/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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_fp8x23/input_1.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_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_fp8x23/output_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 output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 41943040, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_fp8x23_broadcast.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_add_fp8x23_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0 + input_1;
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_fp8x23_broadcast/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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_fp8x23_broadcast/input_1.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_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_fp8x23_broadcast/output_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 output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 33554432, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 33554432, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 33554432, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 33554432, sign: true });
data.append(FP8x23 { mag: 33554432, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_add_i32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0 + input_1;
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32/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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(-1);
data.append(-2);
data.append(-2);
data.append(-1);
data.append(-3);
data.append(1);
data.append(-1);
data.append(0);
data.append(1);
data.append(2);
data.append(1);
data.append(2);
data.append(2);
data.append(0);
data.append(-2);
data.append(2);
data.append(2);
data.append(1);
data.append(-3);
data.append(2);
data.append(-2);
data.append(0);
data.append(-2);
data.append(2);
data.append(-2);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(-2);
data.append(2);
data.append(-2);
data.append(-3);
data.append(-2);
data.append(1);
data.append(-3);
data.append(2);
data.append(0);
data.append(-3);
data.append(2);
data.append(1);
data.append(2);
data.append(0);
data.append(1);
data.append(-3);
data.append(-3);
data.append(0);
data.append(-1);
data.append(-2);
data.append(2);
data.append(-1);
data.append(2);
data.append(1);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(-4);
data.append(0);
data.append(-3);
data.append(-6);
data.append(-1);
data.append(0);
data.append(-3);
data.append(3);
data.append(2);
data.append(-2);
data.append(4);
data.append(3);
data.append(2);
data.append(-2);
data.append(3);
data.append(-1);
data.append(-2);
data.append(-3);
data.append(1);
data.append(-4);
data.append(2);
data.append(-3);
data.append(4);
data.append(-1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32_broadcast.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_add_i32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0 + input_1;
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32_broadcast/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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(-2);
data.append(0);
data.append(-1);
data.append(-3);
data.append(-3);
data.append(-3);
data.append(0);
data.append(1);
data.append(0);
data.append(-2);
data.append(-2);
data.append(1);
data.append(-2);
data.append(1);
data.append(2);
data.append(-3);
data.append(-1);
data.append(-2);
data.append(-3);
data.append(0);
data.append(0);
data.append(0);
data.append(-3);
data.append(1);
data.append(-2);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32_broadcast/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i32_broadcast/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(-3);
data.append(-1);
data.append(-1);
data.append(-3);
data.append(-3);
data.append(-2);
data.append(1);
data.append(2);
data.append(-1);
data.append(-3);
data.append(-3);
data.append(1);
data.append(-2);
data.append(1);
data.append(3);
data.append(-2);
data.append(0);
data.append(-3);
data.append(-4);
data.append(-1);
data.append(0);
data.append(0);
data.append(-3);
data.append(2);
data.append(-1);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8.cairo | mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_add_i8() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0 + input_1;
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8/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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(2);
data.append(-3);
data.append(0);
data.append(0);
data.append(0);
data.append(-3);
data.append(-3);
data.append(-1);
data.append(0);
data.append(-1);
data.append(-2);
data.append(0);
data.append(-3);
data.append(1);
data.append(0);
data.append(-3);
data.append(-3);
data.append(-2);
data.append(1);
data.append(2);
data.append(0);
data.append(2);
data.append(1);
data.append(2);
data.append(1);
data.append(-3);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(0);
data.append(-2);
data.append(2);
data.append(2);
data.append(-3);
data.append(1);
data.append(-2);
data.append(0);
data.append(1);
data.append(2);
data.append(-3);
data.append(-2);
data.append(-1);
data.append(-3);
data.append(-1);
data.append(0);
data.append(-1);
data.append(-2);
data.append(-1);
data.append(2);
data.append(0);
data.append(2);
data.append(2);
data.append(-1);
data.append(2);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(-3);
data.append(-2);
data.append(2);
data.append(2);
data.append(-6);
data.append(-2);
data.append(-3);
data.append(0);
data.append(0);
data.append(0);
data.append(-3);
data.append(-5);
data.append(0);
data.append(-3);
data.append(-4);
data.append(-3);
data.append(-3);
data.append(-1);
data.append(1);
data.append(2);
data.append(2);
data.append(3);
data.append(4);
data.append(0);
data.append(-1);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8_broadcast.cairo | mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_add_i8_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0 + input_1;
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8_broadcast/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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(-2);
data.append(-1);
data.append(0);
data.append(2);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(-2);
data.append(0);
data.append(0);
data.append(1);
data.append(-2);
data.append(0);
data.append(1);
data.append(-3);
data.append(0);
data.append(0);
data.append(1);
data.append(-3);
data.append(-1);
data.append(-3);
data.append(-3);
data.append(-3);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8_broadcast/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(2);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_i8_broadcast/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
fn output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(-3);
data.append(-2);
data.append(2);
data.append(4);
data.append(2);
data.append(0);
data.append(-1);
data.append(-1);
data.append(-1);
data.append(-3);
data.append(-1);
data.append(2);
data.append(3);
data.append(0);
data.append(-1);
data.append(0);
data.append(-4);
data.append(-1);
data.append(-1);
data.append(0);
data.append(-1);
data.append(1);
data.append(-1);
data.append(-4);
data.append(-4);
data.append(-3);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_u32.cairo | mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::U32TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_add_u32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0 + input_1;
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_u32/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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(2);
data.append(2);
data.append(2);
data.append(0);
data.append(1);
data.append(2);
data.append(1);
data.append(2);
data.append(1);
data.append(1);
data.append(0);
data.append(2);
data.append(2);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(2);
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/add_u32/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_1() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(0);
data.append(2);
data.append(1);
data.append(0);
data.append(2);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(0);
data.append(2);
data.append(1);
data.append(1);
data.append(2);
data.append(0);
data.append(0);
data.append(2);
data.append(2);
data.append(0);
data.append(2);
data.append(0);
data.append(2);
data.append(2);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_u32/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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(2);
data.append(2);
data.append(4);
data.append(1);
data.append(1);
data.append(4);
data.append(2);
data.append(4);
data.append(3);
data.append(2);
data.append(0);
data.append(4);
data.append(3);
data.append(2);
data.append(3);
data.append(1);
data.append(1);
data.append(3);
data.append(3);
data.append(1);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(1);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_u32_broadcast.cairo | mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::U32TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_add_u32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0 + input_1;
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_u32_broadcast/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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(1);
data.append(2);
data.append(0);
data.append(1);
data.append(2);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(2);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(2);
data.append(2);
data.append(0);
data.append(2);
data.append(1);
data.append(2);
data.append(2);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_u32_broadcast/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
fn input_1() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(2);
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/add_u32_broadcast/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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(2);
data.append(2);
data.append(3);
data.append(3);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(2);
data.append(4);
data.append(3);
data.append(4);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(1);
data.append(1);
data.append(3);
data.append(4);
data.append(4);
data.append(1);
data.append(3);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool.cairo | mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_and_bool() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = BoolTensor::and(@input_0, @input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn input_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(false);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn input_1() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool_broadcast.cairo | mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_and_bool_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = BoolTensor::and(@input_0, @input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool_broadcast/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn input_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(4);
shape.append(5);
let mut data = ArrayTrait::new();
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool_broadcast/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn input_1() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(4);
shape.append(5);
let mut data = ArrayTrait::new();
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/and_bool_broadcast/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(4);
shape.append(5);
let mut data = ArrayTrait::new();
data.append(true);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_default_axes_keepdims.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_default_axes_keepdims() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(0, Option::Some(true), Option::None(()));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_default_axes_keepdims/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 1, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_default_axes_keepdims/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
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/argmax_default_axes_keepdims_select_last_index.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_default_axes_keepdims_select_last_index() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(0, Option::Some(true), Option::Some(true));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_default_axes_keepdims_select_last_index/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_default_axes_keepdims_select_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
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/argmax_keepdims.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_keepdims() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(1, Option::Some(true), Option::None(()));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_keepdims/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 1, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_keepdims/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_keepdims_select_last_index.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_keepdims_select_last_index() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(1, Option::Some(true), Option::Some(true));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_keepdims_select_last_index/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_keepdims_select_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_negative_axis_keepdims.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_negative_axis_keepdims() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(-1, Option::Some(true), Option::None(()));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_negative_axis_keepdims/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 1, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_negative_axis_keepdims/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_negative_axis_keepdims_select_last_index.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_negative_axis_keepdims_select_last_index() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(-1, Option::Some(true), Option::Some(true));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_negative_axis_keepdims_select_last_index/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_negative_axis_keepdims_select_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_no_keepdims.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_no_keepdims() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(1, Option::Some(false), Option::None(()));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_no_keepdims/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 1, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_no_keepdims/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
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/argmax_no_keepdims_select_last_index.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_argmax_no_keepdims_select_last_index() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = input_0.argmax(1, Option::Some(false), Option::Some(true));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_no_keepdims_select_last_index/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 10, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmax_no_keepdims_select_last_index/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
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_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_1D_default/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(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 3538944, sign: false });
data.append(FP16x16 { mag: 6553600, sign: true });
data.append(FP16x16 { mag: 1900544, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_1D_keepdims_false/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(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 7208960, sign: false });
data.append(FP16x16 { mag: 3801088, sign: false });
data.append(FP16x16 { mag: 720896, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_1D_last_index/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(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 7143424, sign: false });
data.append(FP16x16 { mag: 5177344, sign: false });
data.append(FP16x16 { mag: 5963776, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_2D_default/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 7667712, sign: true });
data.append(FP16x16 { mag: 7798784, sign: false });
data.append(FP16x16 { mag: 5832704, sign: false });
data.append(FP16x16 { mag: 1310720, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_2D_keepdims_false/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 6488064, sign: true });
data.append(FP16x16 { mag: 2424832, sign: false });
data.append(FP16x16 { mag: 6815744, sign: true });
data.append(FP16x16 { mag: 4128768, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_2D_last_index/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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1376256, sign: true });
data.append(FP16x16 { mag: 5898240, sign: true });
data.append(FP16x16 { mag: 6356992, sign: true });
data.append(FP16x16 { mag: 2883584, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_3D_default/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(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 3342336, sign: false });
data.append(FP16x16 { mag: 7602176, sign: true });
data.append(FP16x16 { mag: 3211264, sign: false });
data.append(FP16x16 { mag: 2490368, sign: true });
data.append(FP16x16 { mag: 589824, sign: false });
data.append(FP16x16 { mag: 5570560, sign: true });
data.append(FP16x16 { mag: 1900544, sign: true });
data.append(FP16x16 { mag: 5898240, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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(0);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_3D_keepdims_false/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(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 6422528, sign: true });
data.append(FP16x16 { mag: 1245184, sign: false });
data.append(FP16x16 { mag: 6356992, sign: false });
data.append(FP16x16 { mag: 4718592, sign: true });
data.append(FP16x16 { mag: 6488064, sign: true });
data.append(FP16x16 { mag: 4390912, sign: true });
data.append(FP16x16 { mag: 5046272, sign: false });
data.append(FP16x16 { mag: 2752512, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_argmin_fp16x16_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_fp16x16_3D_last_index/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(2);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1966080, sign: false });
data.append(FP16x16 { mag: 4653056, sign: false });
data.append(FP16x16 { mag: 1835008, sign: false });
data.append(FP16x16 { mag: 5767168, sign: true });
data.append(FP16x16 { mag: 7929856, sign: true });
data.append(FP16x16 { mag: 2162688, sign: true });
data.append(FP16x16 { mag: 4718592, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp16x16_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(1);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_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::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_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_fp8x23_1D_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(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 880803840, sign: true });
data.append(FP8x23 { mag: 528482304, sign: false });
data.append(FP8x23 { mag: 553648128, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_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_fp8x23_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::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_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_fp8x23_1D_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(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 696254464, sign: true });
data.append(FP8x23 { mag: 402653184, sign: true });
data.append(FP8x23 { mag: 310378496, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_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_fp8x23_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::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_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_fp8x23_1D_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(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 478150656, sign: true });
data.append(FP8x23 { mag: 301989888, sign: true });
data.append(FP8x23 { mag: 369098752, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/argmin_fp8x23_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_fp8x23_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::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_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 |