text
stringlengths 1
2.05k
|
|---|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::nn::FP16x16NN;
#[test]
#[available_gas(2000000000)]
fn test_hard_sigmoid_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::hard_sigmoid(
@input_0, @FixedTrait::new(13107, false), @FixedTrait::new(32768, false)
);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
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: 163137, sign: false });
data.append(FP16x16 { mag: 109300, sign: true });
data.append(FP16x16 { mag: 28237, sign: false });
data.append(FP16x16 { mag: 20376, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65395, sign: false });
data.append(FP16x16 { mag: 10907, sign: false });
data.append(FP16x16 { mag: 38415, sign: false });
data.append(FP16x16 { mag: 28692, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::nn::FP8x23NN;
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
#[test]
#[available_gas(2000000000)]
fn test_hard_sigmoid_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::hard_sigmoid(
@input_0, @FixedTrait::new(1677721, false), @FixedTrait::new(4194304, 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: 1488696, sign: true });
data.append(FP8x23 { mag: 14193978, sign: true });
data.append(FP8x23 { mag: 23668532, sign: true });
data.append(FP8x23 { mag: 19142362, sign: false });
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: 3896564, sign: false });
data.append(FP8x23 { mag: 1355508, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8022776, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_fP16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
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: 1, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 4, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 4, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_fP8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
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: 1, sign: false });
data.append(FP8x23 { mag: 2, sign: false });
data.append(FP8x23 { mag: 3, sign: false });
data.append(FP8x23 { mag: 4, sign: false });
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: 1, sign: false });
data.append(FP8x23 { mag: 2, sign: false });
data.append(FP8x23 { mag: 3, sign: false });
data.append(FP8x23 { mag: 4, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorSub};
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorSub};
fn input_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(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorSub};
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(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::operators::tensor::{I8Tensor, I8TensorSub};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorSub};
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(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorSub};
fn output_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(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{U32Tensor, U32TensorSub};
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_u32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorSub};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorSub};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 78643, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FP16x16 { mag: 183500, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FixedTrait::NEG_INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 10066329, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FP8x23 { mag: 23488102, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FixedTrait::NEG_INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_inf_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_u32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF());
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
use orion::operators::tensor::BoolTensor;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_nan_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_nan(@input_0);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 78643, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FixedTrait::NaN());
data.append(FP16x16 { mag: 183500, sign: false });
data.append(FixedTrait::NaN());
data.append(FixedTrait::NaN());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_nan_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_nan(@input_0);
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(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 10066329, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FixedTrait::NaN());
data.append(FP8x23 { mag: 23488102, sign: false });
data.append(FixedTrait::NaN());
data.append(FixedTrait::NaN());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FP16x16 { mag: 2, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FixedTrait::POS_INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FP8x23 { mag: 2, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FixedTrait::POS_INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 4294967295, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 4294967295, sign: true });
data.append(FP16x16 { mag: 4294967295, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 4294967295, sign: false });
data.append(FP8x23 { mag: 2, sign: false });
data.append(FP8x23 { mag: 4294967295, sign: true });
data.append(FP8x23 { mag: 4294967295, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
|
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(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod input_3;
mod output_0;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_label_encoder_fp16x16_3d_default() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let input_3 = input_3::input_3();
let z_0 = output_0::output_0();
let y_0 = input_0
.label_encoder(
default_list: Option::None,
default_tensor: Option::Some(input_1),
keys: Option::None,
keys_tensor: Option::Some(input_2),
values: Option::None,
values_tensor: Option::Some(input_3)
);
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(9);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 393216, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, 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();
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 6488064, 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_2() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 393216, 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_3() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 720896, sign: false });
data.append(FP16x16 { mag: 1441792, sign: false });
data.append(FP16x16 { mag: 3604480, sign: false });
data.append(FP16x16 { mag: 4325376, 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 output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(9);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 720896, sign: false });
data.append(FP16x16 { mag: 1441792, sign: false });
data.append(FP16x16 { mag: 6488064, sign: false });
data.append(FP16x16 { mag: 6488064, sign: false });
data.append(FP16x16 { mag: 3604480, sign: false });
data.append(FP16x16 { mag: 4325376, sign: false });
data.append(FP16x16 { mag: 720896, sign: false });
data.append(FP16x16 { mag: 1441792, sign: false });
data.append(FP16x16 { mag: 6488064, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod input_3;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_label_encoder_fp8x23_default() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let input_3 = input_3::input_3();
let z_0 = output_0::output_0();
let y_0 = input_0
.label_encoder(
default_list: Option::None,
default_tensor: Option::Some(input_1),
keys: Option::None,
keys_tensor: Option::Some(input_2),
values: Option::None,
values_tensor: Option::Some(input_3)
);
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(11);
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 });
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: 58720256, sign: false });
data.append(FP8x23 { mag: 67108864, 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();
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 830472192, 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_2() -> 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: 41943040, sign: false });
data.append(FP8x23 { mag: 50331648, sign: false });
data.append(FP8x23 { mag: 58720256, 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_3() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 92274688, sign: false });
data.append(FP8x23 { mag: 184549376, sign: false });
data.append(FP8x23 { mag: 461373440, sign: false });
data.append(FP8x23 { mag: 553648128, sign: false });
data.append(FP8x23 { mag: 645922816, 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 output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(11);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 92274688, sign: false });
data.append(FP8x23 { mag: 184549376, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
data.append(FP8x23 { mag: 461373440, sign: false });
data.append(FP8x23 { mag: 553648128, sign: false });
data.append(FP8x23 { mag: 92274688, sign: false });
data.append(FP8x23 { mag: 184549376, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
data.append(FP8x23 { mag: 645922816, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod input_3;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_label_encoder_i32_default() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let input_3 = input_3::input_3();
let z_0 = output_0::output_0();
let y_0 = input_0
.label_encoder(
default_list: Option::None,
default_tensor: Option::Some(input_1),
keys: Option::None,
keys_tensor: Option::Some(input_2),
values: Option::None,
values_tensor: Option::Some(input_3)
);
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(11);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
data.append(1);
data.append(2);
data.append(3);
data.append(7);
data.append(8);
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();
let mut data = ArrayTrait::new();
data.append(99);
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_2() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(5);
data.append(6);
data.append(7);
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_3() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(11);
data.append(22);
data.append(55);
data.append(66);
data.append(77);
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(11);
let mut data = ArrayTrait::new();
data.append(11);
data.append(22);
data.append(99);
data.append(99);
data.append(55);
data.append(66);
data.append(11);
data.append(22);
data.append(99);
data.append(77);
data.append(99);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod input_3;
mod output_0;
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::I8TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_label_encoder_i8_default() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let input_3 = input_3::input_3();
let z_0 = output_0::output_0();
let y_0 = input_0
.label_encoder(
default_list: Option::None,
default_tensor: Option::Some(input_1),
keys: Option::None,
keys_tensor: Option::Some(input_2),
values: Option::None,
values_tensor: Option::Some(input_3)
);
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(11);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
data.append(1);
data.append(2);
data.append(3);
data.append(7);
data.append(8);
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();
let mut data = ArrayTrait::new();
data.append(99);
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_2() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(5);
data.append(6);
data.append(7);
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_3() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(11);
data.append(22);
data.append(55);
data.append(66);
data.append(77);
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 output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(11);
let mut data = ArrayTrait::new();
data.append(11);
data.append(22);
data.append(99);
data.append(99);
data.append(55);
data.append(66);
data.append(11);
data.append(22);
data.append(99);
data.append(77);
data.append(99);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod input_3;
mod output_0;
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_label_encoder_u32_default() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let input_3 = input_3::input_3();
let z_0 = output_0::output_0();
let y_0 = input_0
.label_encoder(
default_list: Option::None,
default_tensor: Option::Some(input_1),
keys: Option::None,
keys_tensor: Option::Some(input_2),
values: Option::None,
values_tensor: Option::Some(input_3)
);
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(11);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
data.append(5);
data.append(6);
data.append(1);
data.append(2);
data.append(3);
data.append(7);
data.append(8);
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();
let mut data = ArrayTrait::new();
data.append(99);
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_2() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(5);
data.append(6);
data.append(7);
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_3() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(11);
data.append(22);
data.append(55);
data.append(66);
data.append(77);
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 output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(11);
let mut data = ArrayTrait::new();
data.append(11);
data.append(22);
data.append(99);
data.append(99);
data.append(55);
data.append(66);
data.append(11);
data.append(22);
data.append(99);
data.append(77);
data.append(99);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::{FixedTrait, FP16x16};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_layer_normalization_3d_axis0_epsilon() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z_0 = output_0::output_0();
let (y_0, _, _) = input_0
.layer_normalization(
@input_1,
Option::Some(@input_2),
Option::Some(0),
Option::Some(FixedTrait::new(6554, false)),
Option::None
);
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(3);
shape.append(5);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 176084, sign: true });
data.append(FP16x16 { mag: 134870, sign: false });
data.append(FP16x16 { mag: 11194, sign: true });
data.append(FP16x16 { mag: 34834, sign: true });
data.append(FP16x16 { mag: 6625, sign: true });
data.append(FP16x16 { mag: 99311, sign: true });
data.append(FP16x16 { mag: 84659, sign: true });
data.append(FP16x16 { mag: 37723, sign: false });
data.append(FP16x16 { mag: 78508, sign: true });
data.append(FP16x16 { mag: 31024, sign: false });
data.append(FP16x16 { mag: 72988, sign: true });
data.append(FP16x16 { mag: 9818, sign: true });
data.append(FP16x16 { mag: 34996, sign: false });
data.append(FP16x16 { mag: 87265, sign: true });
data.append(FP16x16 { mag: 45795, sign: true });
data.append(FP16x16 { mag: 45583, sign: true });
data.append(FP16x16 { mag: 10423, sign: true });
data.append(FP16x16 { mag: 71376, sign: true });
data.append(FP16x16 { mag: 31238, sign: true });
data.append(FP16x16 { mag: 84702, sign: false });
data.append(FP16x16 { mag: 18617, sign: true });
data.append(FP16x16 { mag: 90788, sign: false });
data.append(FP16x16 { mag: 32546, sign: true });
data.append(FP16x16 { mag: 43302, sign: true });
data.append(FP16x16 { mag: 90009, sign: true });
data.append(FP16x16 { mag: 19958, sign: true });
data.append(FP16x16 { mag: 161585, sign: false });
data.append(FP16x16 { mag: 40607, sign: false });
data.append(FP16x16 { mag: 34601, sign: true });
data.append(FP16x16 { mag: 7286, 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(2);
shape.append(3);
shape.append(5);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 41116, sign: true });
data.append(FP16x16 { mag: 33345, sign: false });
data.append(FP16x16 { mag: 16035, sign: true });
data.append(FP16x16 { mag: 66324, sign: true });
data.append(FP16x16 { mag: 65521, sign: false });
data.append(FP16x16 { mag: 44567, sign: false });
data.append(FP16x16 { mag: 12343, sign: true });
data.append(FP16x16 { mag: 22182, sign: false });
data.append(FP16x16 { mag: 68006, sign: false });
data.append(FP16x16 { mag: 18564, sign: true });
data.append(FP16x16 { mag: 159060, sign: true });
data.append(FP16x16 { mag: 41449, sign: false });
data.append(FP16x16 { mag: 21502, sign: true });
data.append(FP16x16 { mag: 23583, sign: true });
data.append(FP16x16 { mag: 10004, sign: true });
data.append(FP16x16 { mag: 111077, sign: true });
data.append(FP16x16 { mag: 51023, sign: true });
data.append(FP16x16 { mag: 27845, sign: false });
data.append(FP16x16 { mag: 548, sign: false });
data.append(FP16x16 { mag: 51940, sign: true });
data.append(FP16x16 { mag: 4135, sign: false });
data.append(FP16x16 { mag: 77167, sign: false });
data.append(FP16x16 { mag: 27642, sign: true });
data.append(FP16x16 { mag: 50063, sign: true });
data.append(FP16x16 { mag: 60555, sign: true });
data.append(FP16x16 { mag: 34923, sign: true });
data.append(FP16x16 { mag: 66185, sign: false });
data.append(FP16x16 { mag: 1845, sign: true });
data.append(FP16x16 { mag: 63811, sign: true });
data.append(FP16x16 { mag: 30524, 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_2() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(3);
shape.append(5);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 53067, sign: false });
data.append(FP16x16 { mag: 12598, sign: false });
data.append(FP16x16 { mag: 22071, sign: true });
data.append(FP16x16 { mag: 185160, sign: true });
data.append(FP16x16 { mag: 71946, sign: true });
data.append(FP16x16 { mag: 109757, sign: false });
data.append(FP16x16 { mag: 53829, sign: true });
data.append(FP16x16 { mag: 61215, sign: true });
data.append(FP16x16 { mag: 112863, sign: false });
data.append(FP16x16 { mag: 64576, sign: true });
data.append(FP16x16 { mag: 14400, sign: true });
data.append(FP16x16 { mag: 47376, sign: false });
data.append(FP16x16 { mag: 42132, sign: false });
data.append(FP16x16 { mag: 15521, sign: true });
data.append(FP16x16 { mag: 19564, sign: false });
data.append(FP16x16 { mag: 17481, sign: true });
data.append(FP16x16 { mag: 1740, sign: true });
data.append(FP16x16 { mag: 111657, sign: false });
data.append(FP16x16 { mag: 112934, sign: false });
data.append(FP16x16 { mag: 19870, sign: true });
data.append(FP16x16 { mag: 122950, sign: true });
data.append(FP16x16 { mag: 92754, sign: false });
data.append(FP16x16 { mag: 3247, sign: false });
data.append(FP16x16 { mag: 74346, sign: true });
data.append(FP16x16 { mag: 98767, sign: false });
data.append(FP16x16 { mag: 8702, sign: true });
data.append(FP16x16 { mag: 40643, sign: true });
data.append(FP16x16 { mag: 138135, sign: true });
data.append(FP16x16 { mag: 22240, sign: false });
data.append(FP16x16 { mag: 1595, sign: true });
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.