file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
tests/nodes/cumsum_fp8x23_1d_reverse.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_fp8x23_1d_reverse() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(false), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 125829120, sign: false });
data.append(FP8x23 { mag: 117440512, sign: false });
data.append(FP8x23 { mag: 100663296, sign: false });
data.append(FP8x23 { mag: 75497472, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_1d_reverse_exclusive.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_fp8x23_1d_reverse_exclusive() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(true), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 117440512, sign: false });
data.append(FP8x23 { mag: 100663296, sign: false });
data.append(FP8x23 { mag: 75497472, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_2d_axis_0.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_fp8x23_2d_axis_0() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_2d_axis_0/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(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
data.append(FP8x23 { mag: 50331648, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_2d_axis_0/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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
data.append(FP8x23 { mag: 58720256, sign: false });
data.append(FP8x23 { mag: 75497472, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_2d_axis_1.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_fp8x23_2d_axis_1() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(1, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_2d_axis_1/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(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
data.append(FP8x23 { mag: 50331648, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_fp8x23_2d_axis_1/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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 50331648, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 75497472, sign: false });
data.append(FP8x23 { mag: 125829120, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_default.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i32_1d_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_default/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(3);
data.append(6);
data.append(10);
data.append(15);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_exclusive.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i32_1d_exclusive() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(true), Option::Some(false));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(3);
data.append(6);
data.append(10);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_reverse.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i32_1d_reverse() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(false), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(15);
data.append(14);
data.append(12);
data.append(9);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_reverse_exclusive.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i32_1d_reverse_exclusive() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(true), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(14);
data.append(12);
data.append(9);
data.append(5);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_2d_axis_0.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i32_2d_axis_0() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_2d_axis_0/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_2d_axis_0/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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(5);
data.append(7);
data.append(9);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_2d_axis_1.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i32_2d_axis_1() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(1, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_2d_axis_1/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i32_2d_axis_1/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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(3);
data.append(6);
data.append(4);
data.append(9);
data.append(15);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_default.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i8_1d_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_default/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(3);
data.append(6);
data.append(10);
data.append(15);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_exclusive.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i8_1d_exclusive() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(true), Option::Some(false));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(3);
data.append(6);
data.append(10);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_reverse.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i8_1d_reverse() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(false), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(15);
data.append(14);
data.append(12);
data.append(9);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_reverse_exclusive.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i8_1d_reverse_exclusive() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(true), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(14);
data.append(12);
data.append(9);
data.append(5);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_2d_axis_0.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i8_2d_axis_0() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_2d_axis_0/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_2d_axis_0/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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(5);
data.append(7);
data.append(9);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_2d_axis_1.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_i8_2d_axis_1() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(1, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_2d_axis_1/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_i8_2d_axis_1/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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(3);
data.append(6);
data.append(4);
data.append(9);
data.append(15);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_default.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_u32_1d_default() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(3);
data.append(6);
data.append(10);
data.append(15);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_exclusive.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_u32_1d_exclusive() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(true), Option::Some(false));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(3);
data.append(6);
data.append(10);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_reverse.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_u32_1d_reverse() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(false), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_reverse/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(5);
let mut data = ArrayTrait::new();
data.append(15);
data.append(14);
data.append(12);
data.append(9);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_reverse_exclusive.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_u32_1d_reverse_exclusive() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::Some(true), Option::Some(true));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_1d_reverse_exclusive/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(5);
let mut data = ArrayTrait::new();
data.append(14);
data.append(12);
data.append(9);
data.append(5);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_2d_axis_0.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_u32_2d_axis_0() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(0, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_2d_axis_0/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_2d_axis_0/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(5);
data.append(7);
data.append(9);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_2d_axis_1.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_cumsum_u32_2d_axis_1() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.cumsum(1, Option::None(()), Option::None(()));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_2d_axis_1/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/cumsum_u32_2d_axis_1/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(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(3);
data.append(6);
data.append(4);
data.append(9);
data.append(15);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_fp16x16.cairo | mod input_0;
mod output_0;
use orion::operators::nn::FP16x16NN;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_depth_to_space_fp16x16() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = NNTrait::depth_to_space(@input_0, 2, 'DCR');
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_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(1);
shape.append(4);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 172672, sign: false });
data.append(FP16x16 { mag: 110976, sign: true });
data.append(FP16x16 { mag: 102912, sign: true });
data.append(FP16x16 { mag: 146944, sign: true });
data.append(FP16x16 { mag: 159232, sign: false });
data.append(FP16x16 { mag: 130112, sign: false });
data.append(FP16x16 { mag: 106304, sign: false });
data.append(FP16x16 { mag: 26832, sign: false });
data.append(FP16x16 { mag: 26800, sign: false });
data.append(FP16x16 { mag: 172928, sign: true });
data.append(FP16x16 { mag: 177280, sign: true });
data.append(FP16x16 { mag: 102208, sign: false });
data.append(FP16x16 { mag: 11808, sign: true });
data.append(FP16x16 { mag: 111488, sign: true });
data.append(FP16x16 { mag: 53120, sign: true });
data.append(FP16x16 { mag: 165888, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_fp16x16/output_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 output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(4);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 172672, sign: false });
data.append(FP16x16 { mag: 159232, sign: false });
data.append(FP16x16 { mag: 110976, sign: true });
data.append(FP16x16 { mag: 130112, sign: false });
data.append(FP16x16 { mag: 26800, sign: false });
data.append(FP16x16 { mag: 11808, sign: true });
data.append(FP16x16 { mag: 172928, sign: true });
data.append(FP16x16 { mag: 111488, sign: true });
data.append(FP16x16 { mag: 102912, sign: true });
data.append(FP16x16 { mag: 106304, sign: false });
data.append(FP16x16 { mag: 146944, sign: true });
data.append(FP16x16 { mag: 26832, sign: false });
data.append(FP16x16 { mag: 177280, sign: true });
data.append(FP16x16 { mag: 53120, sign: true });
data.append(FP16x16 { mag: 102208, sign: false });
data.append(FP16x16 { mag: 165888, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_fp8x23.cairo | mod input_0;
mod output_0;
use orion::operators::nn::FP8x23NN;
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::FP8x23TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_depth_to_space_fp8x23() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = NNTrait::depth_to_space(@input_0, 2, 'DCR');
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_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(1);
shape.append(4);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 2107888, sign: true });
data.append(FP8x23 { mag: 18609267, sign: false });
data.append(FP8x23 { mag: 21110896, sign: false });
data.append(FP8x23 { mag: 20658169, sign: true });
data.append(FP8x23 { mag: 15019497, sign: false });
data.append(FP8x23 { mag: 18600854, sign: false });
data.append(FP8x23 { mag: 17219045, sign: false });
data.append(FP8x23 { mag: 5826906, sign: false });
data.append(FP8x23 { mag: 1835376, sign: false });
data.append(FP8x23 { mag: 3485937, sign: false });
data.append(FP8x23 { mag: 23249935, sign: true });
data.append(FP8x23 { mag: 428809, sign: false });
data.append(FP8x23 { mag: 20996700, sign: false });
data.append(FP8x23 { mag: 7565588, sign: true });
data.append(FP8x23 { mag: 15581476, sign: true });
data.append(FP8x23 { mag: 7136954, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_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(1);
shape.append(1);
shape.append(4);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 2107888, sign: true });
data.append(FP8x23 { mag: 15019497, sign: false });
data.append(FP8x23 { mag: 18609267, sign: false });
data.append(FP8x23 { mag: 18600854, sign: false });
data.append(FP8x23 { mag: 1835376, sign: false });
data.append(FP8x23 { mag: 20996700, sign: false });
data.append(FP8x23 { mag: 3485937, sign: false });
data.append(FP8x23 { mag: 7565588, sign: true });
data.append(FP8x23 { mag: 21110896, sign: false });
data.append(FP8x23 { mag: 17219045, sign: false });
data.append(FP8x23 { mag: 20658169, sign: true });
data.append(FP8x23 { mag: 5826906, sign: false });
data.append(FP8x23 { mag: 23249935, sign: true });
data.append(FP8x23 { mag: 15581476, sign: true });
data.append(FP8x23 { mag: 428809, sign: false });
data.append(FP8x23 { mag: 7136954, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_i32.cairo | mod input_0;
mod output_0;
use orion::operators::nn::I32NN;
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I32TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_depth_to_space_i32() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = NNTrait::depth_to_space(@input_0, 2, 'CRD');
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_i32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(4);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(-2);
data.append(2);
data.append(0);
data.append(-1);
data.append(-3);
data.append(-3);
data.append(-2);
data.append(0);
data.append(-3);
data.append(2);
data.append(2);
data.append(1);
data.append(0);
data.append(1);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_i32/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(1);
shape.append(4);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(-1);
data.append(-2);
data.append(-3);
data.append(0);
data.append(1);
data.append(-3);
data.append(0);
data.append(2);
data.append(-3);
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/depth_to_space_i8.cairo | mod input_0;
mod output_0;
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::nn::I8NN;
#[test]
#[available_gas(2000000000)]
fn test_depth_to_space_i8() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = NNTrait::depth_to_space(@input_0, 2, 'DCR');
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_i8/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::NumberTrait;
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(4);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(-3);
data.append(0);
data.append(-1);
data.append(0);
data.append(-1);
data.append(2);
data.append(1);
data.append(2);
data.append(-3);
data.append(-2);
data.append(0);
data.append(2);
data.append(0);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_i8/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(4);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(0);
data.append(-3);
data.append(-1);
data.append(2);
data.append(2);
data.append(-3);
data.append(0);
data.append(0);
data.append(2);
data.append(-1);
data.append(1);
data.append(-2);
data.append(1);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_u32.cairo | mod input_0;
mod output_0;
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::nn::U32NN;
#[test]
#[available_gas(2000000000)]
fn test_depth_to_space_u32() {
let input_0 = input_0::input_0();
let z_0 = output_0::output_0();
let y_0 = NNTrait::depth_to_space(@input_0, 2, 'CRD');
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_u32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::numbers::NumberTrait;
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(4);
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(4294967293);
data.append(4294967294);
data.append(2);
data.append(4294967293);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(4294967295);
data.append(4294967293);
data.append(4294967293);
data.append(0);
data.append(0);
data.append(4294967294);
data.append(2);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/depth_to_space_u32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::numbers::NumberTrait;
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(4);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(4294967293);
data.append(2);
data.append(4294967294);
data.append(2);
data.append(4294967295);
data.append(0);
data.append(4294967293);
data.append(4294967294);
data.append(2);
data.append(2);
data.append(4294967293);
data.append(2);
data.append(4294967293);
data.append(2);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp16x16.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_div_fp16x16() {
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/div_fp16x16/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp16x16/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp16x16_broadcast.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_div_fp16x16_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/div_fp16x16_broadcast/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp16x16_broadcast/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp16x16_broadcast/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp8x23.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
#[test]
#[available_gas(2000000000)]
fn test_div_fp8x23() {
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/div_fp8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
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: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp8x23/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
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: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
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: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 4194304, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 4194304, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 4194304, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 4194304, sign: false });
data.append(FP8x23 { mag: 4194304, 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: 8388608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp8x23_broadcast.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
#[test]
#[available_gas(2000000000)]
fn test_div_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/div_fp8x23_broadcast/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
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: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, 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: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp8x23_broadcast/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
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: false });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_fp8x23_broadcast/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
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: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 4194304, sign: false });
data.append(FP8x23 { mag: 4194304, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 4194304, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 4194304, 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: 8388608, 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: 8388608, sign: false });
data.append(FP8x23 { mag: 4194304, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 4194304, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_i32.cairo | mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_div_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/div_i32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
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(2);
data.append(1);
data.append(1);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(1);
data.append(1);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(1);
data.append(2);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/div_i32/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
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(2);
data.append(1);
data.append(2);
data.append(1);
data.append(1);
data.append(1);
data.append(2);
data.append(2);
data.append(2);
data.append(1);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(2);
data.append(1);
data.append(2);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(2);
data.append(2);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.