text
stringlengths 1
2.05k
|
|---|
mod input_0;
mod output_0;
use orion::operators::nn::FP8x23NN;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::nn::NNTrait;
#[test]
#[available_gas(2000000000)]
fn test_leaky_relu_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::leaky_relu(@input_0, @FixedTrait::new(838861, false));
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 14080598, sign: false });
data.append(FP8x23 { mag: 57593374, sign: false });
data.append(FP8x23 { mag: 23686131, sign: false });
data.append(FP8x23 { mag: 26702392, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 14080599, sign: false });
data.append(FP8x23 { mag: 57593376, sign: false });
data.append(FP8x23 { mag: 23686132, sign: false });
data.append(FP8x23 { mag: 2670239, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_fp16x16() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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: 65536, sign: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_fp16x16_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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: 0, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_fp8x23() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_fp8x23_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(1);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_i32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(2);
data.append(-3);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(2);
data.append(-2);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_i32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(2);
data.append(2);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(2);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_i8() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(2);
data.append(-1);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::NumberTrait;
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(2);
data.append(-1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_i8_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(0);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::NumberTrait;
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(2);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_u32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(2);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::numbers::NumberTrait;
fn input_1() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(2);
data.append(5);
data.append(3);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_less_equal_u32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less_equal(@input_1);
assert_eq(y_0, z_0);
}
|
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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(3);
data.append(3);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::numbers::NumberTrait;
fn input_1() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(3);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_fp16x16() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
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: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
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: true });
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: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_fp16x16_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
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: true });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
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: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_fp8x23() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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: 16777216, sign: true });
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: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 25165824, 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: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
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: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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: 16777216, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
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: 25165824, sign: true });
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: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
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: 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: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_fp8x23_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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: 16777216, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
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: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, 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: 25165824, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, 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: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_i32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(-3);
data.append(-1);
data.append(-3);
data.append(2);
data.append(1);
data.append(-2);
data.append(-2);
data.append(-1);
data.append(2);
data.append(-2);
data.append(0);
data.append(2);
data.append(-3);
data.append(-1);
data.append(-2);
data.append(-3);
data.append(-1);
data.append(0);
data.append(-2);
data.append(1);
data.append(-1);
data.append(2);
data.append(1);
data.append(1);
data.append(2);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
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(0);
data.append(0);
data.append(2);
data.append(1);
data.append(-3);
data.append(1);
data.append(1);
data.append(-1);
data.append(0);
data.append(0);
data.append(-2);
data.append(-1);
data.append(1);
data.append(2);
data.append(0);
data.append(2);
data.append(2);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(2);
data.append(2);
data.append(-2);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_i32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(-1);
data.append(-1);
data.append(1);
data.append(2);
data.append(-3);
data.append(-2);
data.append(-3);
data.append(-1);
data.append(-3);
data.append(0);
data.append(-3);
data.append(-1);
data.append(-1);
data.append(2);
data.append(0);
data.append(0);
data.append(-3);
data.append(-2);
data.append(2);
data.append(-3);
data.append(-3);
data.append(2);
data.append(-3);
data.append(0);
data.append(-3);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::NumberTrait;
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(-3);
data.append(-3);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_i8() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(1);
data.append(0);
data.append(-1);
data.append(1);
data.append(1);
data.append(-2);
data.append(2);
data.append(-2);
data.append(-3);
data.append(-2);
data.append(-1);
data.append(-2);
data.append(-1);
data.append(2);
data.append(0);
data.append(-1);
data.append(2);
data.append(2);
data.append(1);
data.append(0);
data.append(2);
data.append(2);
data.append(-1);
data.append(1);
data.append(-1);
data.append(-3);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::NumberTrait;
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(0);
data.append(1);
data.append(2);
data.append(1);
data.append(1);
data.append(1);
data.append(-1);
data.append(1);
data.append(-3);
data.append(-3);
data.append(2);
data.append(-3);
data.append(-2);
data.append(-1);
data.append(-2);
data.append(1);
data.append(-3);
data.append(2);
data.append(2);
data.append(1);
data.append(-3);
data.append(2);
data.append(1);
data.append(0);
data.append(0);
data.append(2);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_i8_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(2);
data.append(1);
data.append(-3);
data.append(1);
data.append(-1);
data.append(-1);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(0);
data.append(-1);
data.append(-3);
data.append(1);
data.append(-1);
data.append(-3);
data.append(-1);
data.append(-2);
data.append(2);
data.append(0);
data.append(1);
data.append(1);
data.append(2);
data.append(-1);
data.append(2);
data.append(-2);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::NumberTrait;
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(-2);
data.append(-1);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_u32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(3);
data.append(3);
data.append(4);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(4);
data.append(1);
data.append(4);
data.append(4);
data.append(5);
data.append(4);
data.append(1);
data.append(2);
data.append(3);
data.append(3);
data.append(4);
data.append(1);
data.append(5);
data.append(1);
data.append(1);
data.append(5);
data.append(4);
data.append(1);
data.append(2);
data.append(3);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::numbers::NumberTrait;
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(1);
data.append(0);
data.append(2);
data.append(5);
data.append(5);
data.append(2);
data.append(2);
data.append(2);
data.append(5);
data.append(4);
data.append(5);
data.append(0);
data.append(3);
data.append(1);
data.append(0);
data.append(0);
data.append(2);
data.append(2);
data.append(1);
data.append(0);
data.append(4);
data.append(0);
data.append(3);
data.append(0);
data.append(0);
data.append(3);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_less_u32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = input_0.less(@input_1);
assert_eq(y_0, z_0);
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(2);
data.append(2);
data.append(2);
data.append(0);
data.append(5);
data.append(5);
data.append(1);
data.append(5);
data.append(5);
data.append(2);
data.append(4);
data.append(4);
data.append(3);
data.append(0);
data.append(4);
data.append(2);
data.append(1);
data.append(3);
data.append(1);
data.append(2);
data.append(3);
data.append(1);
data.append(3);
data.append(4);
data.append(2);
data.append(3);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::numbers::NumberTrait;
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(0);
data.append(4);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
|
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(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::nn::FP16x16NN;
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_linear_fp16x16() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
|
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);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 185755, sign: false });
data.append(FP16x16 { mag: 99924, sign: true });
data.append(FP16x16 { mag: 46055, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 429406, sign: false });
data.append(FP16x16 { mag: 288523, sign: false });
data.append(FP16x16 { mag: 414929, sign: false });
data.append(FP16x16 { mag: 259811, sign: true });
data.append(FP16x16 { mag: 394274, sign: false });
data.append(FP16x16 { mag: 314398, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_2() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 18363, sign: true });
data.append(FP16x16 { mag: 80823, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 467238, sign: false });
data.append(FP16x16 { mag: 1035802, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::numbers::FixedTrait;
use orion::operators::nn::FP8x23NN;
#[test]
#[available_gas(2000000000)]
fn test_linear_fp8x23() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
|
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);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 55312980, sign: false });
data.append(FP8x23 { mag: 3192975, sign: true });
data.append(FP8x23 { mag: 30534236, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 53179762, sign: false });
data.append(FP8x23 { mag: 34716255, sign: false });
data.append(FP8x23 { mag: 6923297, sign: false });
data.append(FP8x23 { mag: 2365083, sign: true });
data.append(FP8x23 { mag: 35449593, sign: true });
data.append(FP8x23 { mag: 46253431, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_2() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 57085261, sign: false });
data.append(FP8x23 { mag: 10010743, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 419729535, sign: false });
data.append(FP8x23 { mag: 176269923, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::I32NN;
use orion::operators::nn::NNTrait;
use orion::operators::tensor::I32TensorPartialEq;
use orion::numbers::FixedTrait;
#[test]
#[available_gas(2000000000)]
fn test_linear_i32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
|
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);
let mut data = ArrayTrait::new();
data.append(5);
data.append(-1);
data.append(3);
TensorTrait::new(shape.span(), data.span())
}
|
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(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(6);
data.append(6);
data.append(5);
data.append(-3);
data.append(6);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_2() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(-3);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(36);
data.append(-9);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::tensor::I8TensorPartialEq;
use orion::numbers::FixedTrait;
use orion::operators::nn::I8NN;
#[test]
#[available_gas(2000000000)]
fn test_linear_i8() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(-3);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.