text
stringlengths 1
2.05k
|
|---|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_fp16x16() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorMul};
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: true });
data.append(FP16x16 { mag: 0, 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: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
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: 65536, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 196608, 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: 196608, sign: true });
data.append(FP16x16 { mag: 131072, 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, FP16x16TensorMul};
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: 0, sign: false });
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: 65536, sign: true });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
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: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
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: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 196608, sign: true });
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::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
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::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_fp16x16_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorMul};
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: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
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::{FP16x16Tensor, FP16x16TensorMul};
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: 131072, 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::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorMul};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_fp8x23() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorMul};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorMul};
use orion::numbers::{FixedTrait, FP8x23};
fn input_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: true });
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: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
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: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 16777216, sign: true });
TensorTrait::new(shape.span(), data.span())
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
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::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorMul};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_fp8x23_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorMul};
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: 16777216, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
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::{FP8x23Tensor, FP8x23TensorMul};
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: 8388608, sign: true });
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::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorMul};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_i32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorMul};
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(-3);
data.append(0);
data.append(-2);
data.append(1);
data.append(-3);
data.append(1);
data.append(1);
data.append(-3);
data.append(1);
data.append(1);
data.append(0);
data.append(-2);
data.append(-3);
data.append(1);
data.append(0);
data.append(-1);
data.append(-1);
data.append(-3);
data.append(-2);
data.append(-1);
data.append(-1);
data.append(-2);
data.append(1);
data.append(2);
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::{I32Tensor, I32TensorMul};
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(-1);
data.append(0);
data.append(-1);
data.append(-2);
data.append(1);
data.append(0);
data.append(-1);
data.append(1);
data.append(-3);
data.append(-2);
data.append(-3);
data.append(-1);
data.append(-3);
data.append(-3);
data.append(2);
data.append(-1);
data.append(0);
data.append(0);
data.append(-2);
data.append(-2);
data.append(2);
data.append(-2);
data.append(-2);
data.append(-1);
data.append(-3);
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::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
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::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorMul};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::I32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_i32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorMul};
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(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, I32TensorMul};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
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::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorMul};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_i8() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorMul};
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(0);
data.append(-1);
data.append(1);
data.append(2);
data.append(1);
data.append(2);
data.append(-1);
data.append(2);
data.append(1);
data.append(1);
data.append(0);
data.append(2);
data.append(-2);
data.append(1);
data.append(0);
data.append(1);
data.append(0);
data.append(2);
data.append(0);
data.append(2);
data.append(0);
data.append(2);
data.append(1);
data.append(2);
data.append(1);
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::{I8Tensor, I8TensorMul};
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(-2);
data.append(-1);
data.append(-1);
data.append(1);
data.append(0);
data.append(1);
data.append(-3);
data.append(1);
data.append(-1);
data.append(0);
data.append(-1);
data.append(0);
data.append(-3);
data.append(2);
data.append(-2);
data.append(-2);
data.append(2);
data.append(2);
data.append(2);
data.append(2);
data.append(-1);
data.append(2);
data.append(-3);
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::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(0);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
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::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{I8Tensor, I8TensorMul};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_i8_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorMul};
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(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, I8TensorMul};
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
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::{U32Tensor, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_u32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorMul};
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(1);
data.append(5);
data.append(5);
data.append(0);
data.append(1);
data.append(0);
data.append(0);
data.append(0);
data.append(5);
data.append(4);
data.append(0);
data.append(5);
data.append(4);
data.append(2);
data.append(3);
data.append(1);
data.append(0);
data.append(1);
data.append(5);
data.append(0);
data.append(5);
data.append(2);
data.append(3);
data.append(0);
data.append(0);
data.append(5);
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, U32TensorMul};
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(4);
data.append(1);
data.append(5);
data.append(3);
data.append(3);
data.append(0);
data.append(0);
data.append(4);
data.append(4);
data.append(1);
data.append(1);
data.append(1);
data.append(5);
data.append(3);
data.append(2);
data.append(2);
data.append(5);
data.append(4);
data.append(3);
data.append(4);
data.append(2);
data.append(4);
data.append(5);
data.append(4);
data.append(2);
data.append(1);
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, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
shape.append(3);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(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(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
data.append(1);
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::{U32Tensor, U32TensorMul};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::U32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_or_u32_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.or(@input_1);
assert_eq(y, z);
}
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorMul};
fn input_0() -> Tensor<u32> {
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(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, U32TensorMul};
fn input_1() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(0);
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, U32TensorMul};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(1);
data.append(1);
data.append(1);
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
#[test]
#[available_gas(2000000000)]
fn test_pow_fp16x16() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.pow(@input_1);
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(3);
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 });
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 input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 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, FP16x16TensorSub};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 1769472, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
#[test]
#[available_gas(2000000000)]
fn test_pow_fp16x16_broadcast() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.pow(@input_1);
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(3);
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 });
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 input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
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::{FP16x16Tensor, FP16x16TensorSub};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 589824, sign: false });
TensorTrait::new(shape.span(), data.span())
}
|
mod input_0;
mod input_1;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
#[test]
#[available_gas(2000000000)]
fn test_pow_fp8x23() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.pow(@input_1);
assert_eq(y, z);
}
|
// mod fixed_point;
mod complex_number_test;
|
use orion::numbers::complex_number::complex_trait::ComplexTrait;
use orion::numbers::complex_number::complex64::{TWO, complex64};
use orion::numbers::{FP64x64, FP64x64Impl, FixedTrait};
use core::debug::PrintTrait; |
fn test_add() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let b = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(36893488147419103232, false),
FixedTrait::<FP64x64>::new(239807672958224171008, false)
);
let result = a + b;
assert(result.real == FixedTrait::<FP64x64>::new(110680464442257309696, false), '4 + 2 = 6');
assert(
result.img == FixedTrait::<FP64x64>::new(1014570924054025338880, false),
'42i + 13i = 55i, b = 55'
);
} |
fn test_sub() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let b = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(36893488147419103232, false),
FixedTrait::<FP64x64>::new(239807672958224171008, false)
);
let result = a - b;
assert(result.real == FixedTrait::<FP64x64>::new(36893488147419103232, false), '4 - 2 = 2');
assert(
result.img == FixedTrait::<FP64x64>::new(534955578137576996864, false),
'42i - 13i = 29i, b = 29'
);
} |
fn test_mul() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let b = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(36893488147419103232, false),
FixedTrait::<FP64x64>::new(239807672958224171008, false)
);
let result = a * b;
assert(
result.real == FixedTrait::<FP64x64>::new(9924348311655738769408, true),
'4*2 - 42*13 = -538'
);
assert(
result.img == FixedTrait::<FP64x64>::new(2508757194024499019776, false),
'(4*13 + 2*42)i = 136i, b = 136'
);
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(0, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let b = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(36893488147419103232, false),
FixedTrait::<FP64x64>::new(239807672958224171008, false)
);
let result = a * b;
assert(
result.real == FixedTrait::<FP64x64>::new(10071922264245415182336, true),
'0*2 - 42*13 = 546'
);
assert(
result.img == FixedTrait::<FP64x64>::new(1549526502191602335744, false),
'(0*13 + 2*42)i = 84, b = 84'
);
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let b = ComplexTrait::<
complex64
>::new(FixedTrait::<FP64x64>::new(0, false), FixedTrait::<FP64x64>::new(0, false));
let result = a * b;
assert(result.real == FixedTrait::<FP64x64>::new(0, false), '0');
assert(result.img == FixedTrait::<FP64x64>::new(0, false), '0');
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(0, false),
FixedTrait::<FP64x64>::new(18446744073709551616, false) |
);
let b = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(0, false),
FixedTrait::<FP64x64>::new(18446744073709551616, false)
);
let result = a * b;
assert(result.real == FixedTrait::<FP64x64>::new(18446744073709551616, true), 'i * i = -1');
assert(result.img == FixedTrait::<FP64x64>::new(0, false), 'i * i = -1 + 0i');
} |
fn test_div_no_rem() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let b = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(36893488147419103232, false),
FixedTrait::<FP64x64>::new(239807672958224171008, false)
);
let result = a / b;
assert(
result.real == FixedTrait::<FP64x64>::new(59072232467254864688, false),
'real = 3.2023121387283235'
);
assert(
result.img == FixedTrait::<FP64x64>::new(3412114510743963284, false),
'img = 0.18497109826589594j'
);
} |
fn test_zero() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let b = ComplexTrait::zero();
let result = a * b;
assert(result.real == FixedTrait::<FP64x64>::new(0, false), 'should be 0');
assert(result.img == FixedTrait::<FP64x64>::new(0, false), 'should be 0');
} |
fn test_conjugate() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let conjugate = a.conjugate();
assert(
conjugate.real == FixedTrait::<FP64x64>::new(73786976294838206464, false),
'conjugate.real = 4'
);
assert(
conjugate.img == FixedTrait::<FP64x64>::new(774763251095801167872, true),
'conjugate.img = -42'
);
} |
fn test_mag() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let mag = a.mag();
assert(mag == FixedTrait::new(0x2a30a6de7900000000, false), 'mag = 42.190046219457976');
} |
fn test_arg() {
let a = ComplexTrait::<
complex64
>::new(
FixedTrait::<FP64x64>::new(73786976294838206464, false),
FixedTrait::<FP64x64>::new(774763251095801167872, false)
);
let arg = a.arg();
assert(
arg == FixedTrait::<FP64x64>::new(27224496882576083824, false), 'arg = 1.4758446204521403'
);
} |
fn test_exp() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let _z = ComplexTrait::exp(a);
let _z_expected: complex64 = ComplexTrait::new(
FixedTrait::new(402848450095324460000, true), FixedTrait::new(923082101320478400000, true)
);
} |
fn test_exp2() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let exp2 = a.exp2();
assert(
exp2.real == FixedTrait::new(197471674372309809080, true), 'exp2.real = -10.70502356986'
);
assert(exp2.img == FixedTrait::new(219354605088992285353, true), 'exp2.img = -11.89127707');
} |
fn test_sqrt() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let sqrt = a.sqrt();
assert(sqrt.real == FixedTrait::new(88650037379463118848, false), 'real = 4.80572815603723');
assert(sqrt.img == FixedTrait::new(80608310115317055488, false), 'img = 4.369785247552674');
} |
fn test_ln() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let ln = a.ln();
assert(ln.real == FixedTrait::new(69031116512113681970, false), 'ln.real = 3.7421843216430655');
assert(ln.img == FixedTrait::new(27224496882576083824, false), 'ln.img = 1.4758446204521403');
} |
fn test_log2() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let log2 = a.log2();
assert(log2.real == FixedTrait::new(34130530934667840346, false), 'log2.real = 1.85021986');
assert(log2.img == FixedTrait::new(26154904847122126193, false), 'log2.img = 1.41787163');
} |
fn test_log10() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let log10 = a.log10();
assert(
log10.real == FixedTrait::new(10274314139629458970, false),
'log10.real = 0.5569716761534184'
);
assert(
log10.img == FixedTrait::new(7873411322133748801, false), 'log10.img = 0.42682189085546657'
);
} |
fn test_acos() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let acos = a.acos();
assert(
acos.real == FixedTrait::new(18449430688981877061, false), 'acos.real = 1.000143542473797'
);
assert(acos.img == FixedTrait::new(36587032881711954470, true), 'acos.img = -1.98338702991653');
} |
fn test_asin() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let asin = a.asin();
assert(asin.real == FixedTrait::new(10526647143326614308, false), 'asin.real = 0.57065278432');
assert(asin.img == FixedTrait::new(36587032881711954470, false), 'asin.img = 1.9833870299');
} |
fn test_atan() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let atan = a.atan();
assert(atan.real == FixedTrait::new(26008453796191787243, false), 'atan.real = 1.40992104959');
assert(atan.img == FixedTrait::new(4225645162986888119, false), 'atan.img = 0.229072682968538');
} |
fn test_cos() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let cos = a.cos();
assert(
cos.real == FixedTrait::new(77284883172661882094, true), 'cos.real = -4.189625690968807'
);
assert(cos.img == FixedTrait::new(168035443352962049425, true), 'cos.img = -9.109227893755337');
} |
fn test_sin() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let sin = a.sin();
assert(
sin.real == FixedTrait::new(168870549816927860082, false), 'sin.real = 9.15449914691143'
);
assert(sin.img == FixedTrait::new(76902690389051588309, true), 'sin.img = -4.168906959966565');
} |
fn test_tan() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let tan = a.tan();
assert(tan.real == FixedTrait::new(69433898428143694, true), 'tan.real = -0.003764025641');
assert(tan.img == FixedTrait::new(18506486100303669886, false), 'tan.img = 1.00323862735361');
} |
fn test_acosh() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let acosh = a.acosh();
assert(acosh.real == FixedTrait::new(36587032878947915965, false), 'acosh.real = 1.9833870');
assert(acosh.img == FixedTrait::new(18449360714192945790, false), 'acosh.img = 1.0001435424');
} |
fn test_asinh() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let asinh = a.asinh();
assert(
asinh.real == FixedTrait::new(36314960239770126586, false), 'asinh.real = 1.96863792579'
);
assert(asinh.img == FixedTrait::new(17794714057579789616, false), 'asinh.img = 0.96465850440');
} |
fn test_atanh() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let atanh = a.atanh();
assert(
atanh.real == FixedTrait::new(2710687792925618924, false), 'atanh.real = 0.146946666225'
);
assert(atanh.img == FixedTrait::new(24699666646262346226, false), 'atanh.img = 1.3389725222');
} |
fn test_cosh() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let cosh = a.cosh();
assert(cosh.real == FixedTrait::new(68705646899632870392, true), 'cosh.real = -3.72454550491');
assert(cosh.img == FixedTrait::new(9441447324287988702, false), 'cosh.img = 0.511822569987');
} |
fn test_sinh() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let sinh = a.sinh();
assert(sinh.real == FixedTrait::new(66234138518106676624, true), 'sinh.real = -3.59056458998');
assert(sinh.img == FixedTrait::new(9793752294470951790, false), 'sinh.img = 0.530921086');
} |
fn test_tanh() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(55340232221128654848, false)
);
let tanh = a.tanh();
assert(tanh.real == FixedTrait::new(17808227710002974080, false), 'tanh.real = 0.96538587902');
assert(tanh.img == FixedTrait::new(182334107030204896, true), 'tanh.img = 0.009884375');
} |
fn test_pow() {
let two = ComplexTrait::new(FP64x64Impl::new(TWO, false), FP64x64Impl::new(0, false));
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let pow = a.pow(two);
assert(pow.real == FixedTrait::new(32244908640844296224768, true), 'pow.real = -1748');
assert(pow.img == FixedTrait::new(6198106008766409342976, false), 'pow.img = 336');
let three: complex64 = ComplexTrait::new(
FP64x64Impl::new(55340232221128654848, false), FP64x64Impl::new(0, false)
);
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let pow = a.pow(three);
assert(pow.real == FixedTrait::new(389305023520047451076807, true), 'pow.real = -21104');
assert(pow.img == FixedTrait::new(1329485652886846033475029, true), 'pow.img = 72072');
let w: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(18446744073709551616, false)
);
let pow = a.pow(w);
assert(
pow.real == FixedTrait::new(6881545343236111419203, false), 'pow.real = 373.0485407816205'
);
assert(
pow.img == FixedTrait::new(2996539405459717736042, false), 'pow.img = 162.4438823807959'
);
} |
fn test_to_polar() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let (mag, arg) = a.to_polar();
assert(mag == FixedTrait::new(778268985067028086784, false), 'mag = 42.190046219457976');
assert(arg == FixedTrait::new(27224496882576083824, false), 'arg = 1.4758446204521403');
} |
fn test_from_polar() {
let mag: FP64x64 = FixedTrait::new(778268985067028086784, false);
let arg: FP64x64 = FixedTrait::new(27224496882576083824, false);
let z_actual: complex64 = ComplexTrait::from_polar(mag, arg);
let z_expected: complex64 = ComplexTrait::new(
FixedTrait::new(73787936714814843012, false), FixedTrait::new(774759489569697723777, false)
);
assert(z_actual == z_expected, 'wrong number');
} |
fn test_reciprocal() {
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
);
let z_actual = a.reciprocal();
let z_expected: complex64 = ComplexTrait::new(
FixedTrait::new(41453357469010228, false), FixedTrait::new(435260253424607397, true)
);
assert(z_actual == z_expected, '0.002247191011 - 0.0235955056 i');
} |
mod erf_fp16x16_test;
mod erf_fp16x16wide_test;
mod erf_fp8x23_test;
mod erf_fp8x23wide_test;
mod erf_fp32x32_test;
mod erf_fp64x64_test;
|
use orion::numbers::fixed_point::implementations::fp16x16::math::erf::erf;
use orion::numbers::fixed_point::implementations::fp16x16::core::{ONE, FP16x16, FixedTrait};
use core::debug::PrintTrait;
#[test]
#[available_gas(1000000000)]
fn test_erf() {
// 1.0
let f1: FP16x16 = FP16x16 { mag: 65536, sign: false };
// 0.134
let f2: FP16x16 = FP16x16 { mag: 8832, sign: false };
// 0.520
let f3: FP16x16 = FP16x16 { mag: 34078, sign: false };
// 2.0
let f4: FP16x16 = FP16x16 { mag: 131072, sign: false };
// 3.5
let f5: FP16x16 = FP16x16 { mag: 229376, sign: false };
// 5.164
let f6: FP16x16 = FP16x16 { mag: 338428, sign: false };
let f1_erf: FP16x16 = erf(f1);
let f2_erf: FP16x16 = erf(f2);
let f3_erf: FP16x16 = erf(f3);
let f4_erf: FP16x16 = erf(f4);
let f5_erf: FP16x16 = erf(f5);
let f6_erf: FP16x16 = erf(f6);
assert(f1_erf.mag == 55227, 'f1_erf it works!');
assert(f2_erf.mag == 10285, 'f2_erf it works!');
assert(f3_erf.mag == 35251, 'f3_erf it works!');
assert(f4_erf.mag == 65229, 'f4_erf it works!');
assert(f5_erf.mag == 65536, 'f5_erf it works!');
assert(f6_erf.mag == 65536, 'f6_erf it works!');
}
|
use orion::numbers::fixed_point::implementations::fp16x16wide::math::erf::erf;
use orion::numbers::fixed_point::implementations::fp16x16wide::core::{ONE, FP16x16W, FixedTrait};
use core::debug::PrintTrait;
#[test]
#[available_gas(1000000000)]
fn test_erf() {
// 1.0
let f1: FP16x16W = FP16x16W { mag: 65536, sign: false };
// 0.134
let f2: FP16x16W = FP16x16W { mag: 8832, sign: false };
// 0.520
let f3: FP16x16W = FP16x16W { mag: 34078, sign: false };
// 2.0
let f4: FP16x16W = FP16x16W { mag: 131072, sign: false };
// 3.5
let f5: FP16x16W = FP16x16W { mag: 229376, sign: false };
// 5.164
let f6: FP16x16W = FP16x16W { mag: 338428, sign: false };
let f1_erf: FP16x16W = erf(f1);
let f2_erf: FP16x16W = erf(f2);
let f3_erf: FP16x16W = erf(f3);
let f4_erf: FP16x16W = erf(f4);
let f5_erf: FP16x16W = erf(f5);
let f6_erf: FP16x16W = erf(f6);
assert(f1_erf.mag == 55227, 'f1_erf it works!');
assert(f2_erf.mag == 10285, 'f2_erf it works!');
assert(f3_erf.mag == 35251, 'f3_erf it works!');
assert(f4_erf.mag == 65229, 'f4_erf it works!');
assert(f5_erf.mag == 65536, 'f5_erf it works!');
assert(f6_erf.mag == 65536, 'f6_erf it works!');
}
|
use orion::numbers::fixed_point::implementations::fp32x32::erf::erf;
use orion::numbers::fixed_point::implementations::fp32x32::core::{ONE, FP32x32, FixedTrait};
use core::debug::PrintTrait;
#[test]
#[available_gas(1000000000)]
fn test_erf() {
// 1.0
let f1: FP32x32 = FP32x32 { mag: 4294967296, sign: false };
// 0.134
let f2: FP32x32 = FP32x32 { mag: 575525618, sign: false };
// 0.520
let f3: FP32x32 = FP32x32 { mag: 2233382993, sign: false };
// 2.0
let f4: FP32x32 = FP32x32 { mag: 8589934592, sign: false };
// 3.5
let f5: FP32x32 = FP32x32 { mag: 15032385536, sign: false };
// 5.164
let f6: FP32x32 = FP32x32 { mag: 22179211117, sign: false };
let f1_erf: FP32x32 = erf(f1);
let f2_erf: FP32x32 = erf(f2);
let f3_erf: FP32x32 = erf(f3);
let f4_erf: FP32x32 = erf(f4);
let f5_erf: FP32x32 = erf(f5);
let f6_erf: FP32x32 = erf(f6);
assert(f1_erf.mag == 3619372346, 'f1_erf it works!');
assert(f2_erf.mag == 674082374, 'f2_erf it works!');
assert(f3_erf.mag == 2310257026, 'f3_erf it works!');
assert(f4_erf.mag == 4274876577, 'f4_erf it works!');
assert(f5_erf.mag == 4294967296, 'f5_erf it works!');
assert(f6_erf.mag == 4294967296, 'f6_erf it works!');
}
|
use orion::numbers::fixed_point::implementations::fp64x64::erf::erf;
use orion::numbers::fixed_point::implementations::fp64x64::core::{ONE, FP64x64, FixedTrait};
use core::debug::PrintTrait;
#[test]
#[available_gas(1000000000)]
fn test_erf() {
// 1.0
let f1: FP64x64 = FP64x64 { mag: 18446744073709551616_u128, sign: false };
// 0.134
let f2: FP64x64 = FP64x64 { mag: 2471863705877080064_u128, sign: false };
// 0.520
let f3: FP64x64 = FP64x64 { mag: 9592306918328967168_u128, sign: false };
// 2.0
let f4: FP64x64 = FP64x64 { mag: 36893488147419103232_u128, sign: false };
// 3.5
let f5: FP64x64 = FP64x64 { mag: 64563604257983430656_u128, sign: false };
// 5.164
let f6: FP64x64 = FP64x64 { mag: 95258986396636119040_u128, sign: false };
let f1_erf: FP64x64 = erf(f1);
let f2_erf: FP64x64 = erf(f2);
let f3_erf: FP64x64 = erf(f3);
let f4_erf: FP64x64 = erf(f4);
let f5_erf: FP64x64 = erf(f5);
let f6_erf: FP64x64 = erf(f6);
assert(f1_erf.mag == 15545085858255493120_u128, 'f1_erf it works!');
assert(f2_erf.mag == 2895161752038532608_u128, 'f2_erf it works!');
assert(f3_erf.mag == 9922478374042292224_u128, 'f3_erf it works!');
assert(f4_erf.mag == 18360455093669533696_u128, 'f4_erf it works!');
assert(f5_erf.mag == 18446744073709551616_u128, 'f5_erf it works!');
assert(f6_erf.mag == 18446744073709551616_u128, 'f6_erf it works!');
}
|
use orion::numbers::fixed_point::implementations::fp8x23::math::erf::erf;
use orion::numbers::fixed_point::implementations::fp8x23::core::{ONE, FP8x23, FixedTrait};
use core::debug::PrintTrait;
#[test]
#[available_gas(1000000000)]
fn test_erf() {
// 1.0
let f1: FP8x23 = FP8x23 { mag: 8388608, sign: false };
// 0.134
let f2: FP8x23 = FP8x23 { mag: 1124073, sign: false };
// 0.520
let f3: FP8x23 = FP8x23 { mag: 4362076, sign: false };
// 2.0
let f4: FP8x23 = FP8x23 { mag: 16777216, sign: false };
// 3.5
let f5: FP8x23 = FP8x23 { mag: 29360128, sign: false };
// 5.164
let f6: FP8x23 = FP8x23 { mag: 43318772, sign: false };
let f1_erf: FP8x23 = erf(f1);
let f2_erf: FP8x23 = erf(f2);
let f3_erf: FP8x23 = erf(f3);
let f4_erf: FP8x23 = erf(f4);
let f5_erf: FP8x23 = erf(f5);
let f6_erf: FP8x23 = erf(f6);
assert(f1_erf.mag == 7069086, 'f1_erf it works!');
assert(f2_erf.mag == 1316567, 'f2_erf it works!');
assert(f3_erf.mag == 4512220, 'f3_erf it works!');
assert(f4_erf.mag == 8349368, 'f4_erf it works!');
assert(f5_erf.mag == 8388608, 'f5_erf it works!');
assert(f6_erf.mag == 8388608, 'f6_erf it works!');
}
|
use orion::numbers::fixed_point::implementations::fp8x23wide::math::erf::erf;
use orion::numbers::fixed_point::implementations::fp8x23wide::core::{ONE, FP8x23W, FixedTrait};
use core::debug::PrintTrait;
#[test]
#[available_gas(1000000000)]
fn test_erf() {
// 1.0
let f1: FP8x23W = FP8x23W { mag: 8388608, sign: false };
// 0.134
let f2: FP8x23W = FP8x23W { mag: 1124073, sign: false };
// 0.520
let f3: FP8x23W = FP8x23W { mag: 4362076, sign: false };
// 2.0
let f4: FP8x23W = FP8x23W { mag: 16777216, sign: false };
// 3.5
let f5: FP8x23W = FP8x23W { mag: 29360128, sign: false };
// 5.164
let f6: FP8x23W = FP8x23W { mag: 43318772, sign: false };
let f1_erf: FP8x23W = erf(f1);
let f2_erf: FP8x23W = erf(f2);
let f3_erf: FP8x23W = erf(f3);
let f4_erf: FP8x23W = erf(f4);
let f5_erf: FP8x23W = erf(f5);
let f6_erf: FP8x23W = erf(f6);
assert(f1_erf.mag == 7069086, 'f1_erf it works!');
assert(f2_erf.mag == 1316567, 'f2_erf it works!');
assert(f3_erf.mag == 4512220, 'f3_erf it works!');
assert(f4_erf.mag == 8349368, 'f4_erf it works!');
assert(f5_erf.mag == 8388608, 'f5_erf it works!');
assert(f6_erf.mag == 8388608, 'f6_erf it works!');
}
|
mod transpose_test;
mod qlinear_matmul_test;
mod qlinear_concat_test;
mod qlinear_add_test;
mod constant_of_shape_test;
mod qlinear_leakyrelu_test;
mod optional;
|
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor, U32Tensor};
use core::debug::PrintTrait;
#[test]
#[available_gas(200000000000)]
fn constant_of_shape_test() {
let tensor = TensorTrait::<u32>::constant_of_shape(shape: array![4, 2].span(), value: 20);
assert(tensor.shape == array![4, 2].span(), 'wrong dim');
assert(tensor.data == array![20, 20, 20, 20, 20, 20, 20, 20].span(), 'wrong values');
}
|
mod optional_test;
mod optional_has_element_test;
mod optional_get_element_test;
|
use core::debug::PrintTrait;
use core::array::{ArrayTrait, SpanTrait};
use core::option::OptionTrait;
use orion::operators::tensor::{TensorTrait, Tensor, I8Tensor, I32Tensor, U32Tensor, FP16x16Tensor};
use orion::numbers::{FP16x16, FP16x16Impl, FP32x32, FP32x32Impl, FixedTrait};
use orion::numbers::{NumberTrait};
use orion::operators::tensor::helpers::{optional_has_element, optional_get_element}; |
fn optional_get_element_i8_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![4, 2].span(),
data: array![1_i8, 2_i8, 3_i8, 4_i8, 5_i8, 6_i8, 7_i8, 8_i8].span(),
);
let ele = optional_get_element(a.optional());
assert(*(ele.data).at(0) == *(a.data).at(0), 'ele[0] == a[0]');
assert(*(ele.data).at(1) == *(a.data).at(1), 'ele[1] == a[1]');
assert(*(ele.data).at(2) == *(a.data).at(2), 'ele[2] == a[2]');
assert(*(ele.data).at(3) == *(a.data).at(3), 'ele[3] == a[3]');
assert(*(ele.data).at(4) == *(a.data).at(4), 'ele[4] == a[4]');
assert(*(ele.data).at(5) == *(a.data).at(5), 'ele[5] == a[5]');
assert(*(ele.data).at(6) == *(a.data).at(6), 'ele[6] == a[6]');
assert(*(ele.data).at(7) == *(a.data).at(7), 'ele[7] == a[7]');
} |
fn optional_get_element_fp16x16_test() {
let a = TensorTrait::<
FP16x16
>::new(
shape: array![4, 2].span(),
data: array![
FixedTrait::<FP16x16>::new_unscaled(1, false),
FixedTrait::<FP16x16>::new_unscaled(2, false),
FixedTrait::<FP16x16>::new_unscaled(3, false),
FixedTrait::<FP16x16>::new_unscaled(4, false),
FixedTrait::<FP16x16>::new_unscaled(5, false),
FixedTrait::<FP16x16>::new_unscaled(6, false),
FixedTrait::<FP16x16>::new_unscaled(7, false),
FixedTrait::<FP16x16>::new_unscaled(8, false)
]
.span(),
);
let ele = optional_get_element(a.optional());
assert(*(ele.data).at(0) == *(a.data).at(0), 'ele[0] == a[0]');
assert(*(ele.data).at(1) == *(a.data).at(1), 'ele[1] == a[1]');
assert(*(ele.data).at(2) == *(a.data).at(2), 'ele[2] == a[2]');
assert(*(ele.data).at(3) == *(a.data).at(3), 'ele[3] == a[3]');
assert(*(ele.data).at(4) == *(a.data).at(4), 'ele[4] == a[4]');
assert(*(ele.data).at(5) == *(a.data).at(5), 'ele[5] == a[5]');
assert(*(ele.data).at(6) == *(a.data).at(6), 'ele[6] == a[6]');
assert(*(ele.data).at(7) == *(a.data).at(7), 'ele[7] == a[7]');
} |
use core::debug::PrintTrait;
use core::array::{ArrayTrait, SpanTrait};
use core::option::OptionTrait;
use orion::operators::tensor::{TensorTrait, Tensor, I8Tensor, I32Tensor, U32Tensor, FP16x16Tensor};
use orion::numbers::{FP16x16, FP16x16Impl, FP32x32, FP32x32Impl, FixedTrait};
use orion::numbers::{NumberTrait};
use orion::operators::tensor::helpers::{optional_has_element, optional_get_element};
#[test]
#[available_gas(200000000000)]
fn optional_has_element_i8_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![4, 2].span(),
data: array![1_i8, 2_i8, 3_i8, 4_i8, 5_i8, 6_i8, 7_i8, 8_i8].span(),
);
let a_optional = a.optional();
let has_ele = optional_has_element(a_optional);
assert(*(has_ele.data).at(0) == true, 'has_ele[0] == true');
}
#[test]
#[available_gas(200000000000)]
fn optional_has_element_fp16x16_test() {
let a = TensorTrait::<
FP16x16
>::new(
shape: array![4, 2].span(),
data: array![
FixedTrait::<FP16x16>::new_unscaled(1, false),
FixedTrait::<FP16x16>::new_unscaled(2, false),
FixedTrait::<FP16x16>::new_unscaled(3, false),
FixedTrait::<FP16x16>::new_unscaled(4, false),
FixedTrait::<FP16x16>::new_unscaled(5, false),
FixedTrait::<FP16x16>::new_unscaled(6, false),
FixedTrait::<FP16x16>::new_unscaled(7, false),
FixedTrait::<FP16x16>::new_unscaled(8, false)
]
.span(),
);
let a_optional = a.optional();
let has_ele = optional_has_element(a_optional);
assert(*(has_ele.data).at(0) == true, 'has_ele[0] == true');
}
#[test]
#[available_gas(200000000000)]
fn optional_has_element_none_test() {
let a: Option<Tensor<u32>> = Option::None(());
let has_ele = optional_has_element(a);
assert(*(has_ele.data).at(0) == false, 'has_ele[0] == false');
}
|
use core::debug::PrintTrait;
use core::array::{ArrayTrait, SpanTrait};
use core::option::OptionTrait;
use orion::operators::tensor::{TensorTrait, Tensor, I8Tensor, I32Tensor, U32Tensor, FP16x16Tensor};
use orion::numbers::{FP16x16, FP16x16Impl, FP32x32, FP32x32Impl, FixedTrait};
use orion::numbers::{NumberTrait};
use orion::operators::tensor::helpers::{optional_has_element, optional_get_element}; |
fn optional_i8_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![4, 2].span(),
data: array![1_i8, 2_i8, 3_i8, 4_i8, 5_i8, 6_i8, 7_i8, 8_i8].span(),
);
let a_optional = a.optional();
assert(
*(optional_get_element(a_optional).data).at(0) == *(a.data).at(0),
'a_optional[0] == Option(a)[0]'
);
assert(
*(optional_get_element(a_optional).data).at(1) == *(a.data).at(1),
'a_optional[1] == Option(a)[1]'
);
assert(
*(optional_get_element(a_optional).data).at(2) == *(a.data).at(2),
'a_optional[2] == Option(a)[2]'
);
assert(
*(optional_get_element(a_optional).data).at(3) == *(a.data).at(3),
'a_optional[3] == Option(a)[3]'
);
assert(
*(optional_get_element(a_optional).data).at(4) == *(a.data).at(4),
'a_optional[4] == Option(a)[4]'
);
assert(
*(optional_get_element(a_optional).data).at(5) == *(a.data).at(5),
'a_optional[5] == Option(a)[5]'
);
assert(
*(optional_get_element(a_optional).data).at(6) == *(a.data).at(6),
'a_optional[6] == Option(a)[6]'
);
assert(
*(optional_get_element(a_optional).data).at(7) == *(a.data).at(7),
'a_optional[7] == Option(a)[7]'
);
} |
fn optional_fp16x16_test() {
let a = TensorTrait::<
FP16x16
>::new(
shape: array![4, 2].span(),
data: array![
FixedTrait::<FP16x16>::new_unscaled(1, false),
FixedTrait::<FP16x16>::new_unscaled(2, false),
FixedTrait::<FP16x16>::new_unscaled(3, false),
FixedTrait::<FP16x16>::new_unscaled(4, false),
FixedTrait::<FP16x16>::new_unscaled(5, false),
FixedTrait::<FP16x16>::new_unscaled(6, false),
FixedTrait::<FP16x16>::new_unscaled(7, false),
FixedTrait::<FP16x16>::new_unscaled(8, false)
]
.span(),
);
let a_optional = a.optional();
assert(
*(optional_get_element(a_optional).data).at(0) == *(a.data).at(0),
'a_optional[0] == Option(a)[0]'
);
assert(
*(optional_get_element(a_optional).data).at(1) == *(a.data).at(1),
'a_optional[1] == Option(a)[1]'
);
assert(
*(optional_get_element(a_optional).data).at(2) == *(a.data).at(2),
'a_optional[2] == Option(a)[2]'
);
assert(
*(optional_get_element(a_optional).data).at(3) == *(a.data).at(3),
'a_optional[3] == Option(a)[3]'
);
assert(
*(optional_get_element(a_optional).data).at(4) == *(a.data).at(4),
'a_optional[4] == Option(a)[4]'
);
assert(
*(optional_get_element(a_optional).data).at(5) == *(a.data).at(5),
'a_optional[5] == Option(a)[5]'
);
assert(
*(optional_get_element(a_optional).data).at(6) == *(a.data).at(6),
'a_optional[6] == Option(a)[6]'
);
assert(
*(optional_get_element(a_optional).data).at(7) == *(a.data).at(7),
'a_optional[7] == Option(a)[7]'
);
} |
use core::debug::PrintTrait;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor, I8Tensor, I32Tensor, U32Tensor, FP16x16Tensor};
use orion::numbers::{FP16x16, FP16x16Impl, FP32x32, FP32x32Impl, FixedTrait};
use orion::numbers::{NumberTrait}; |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.