file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
tests/nodes/or_fp8x23_broadcast.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_fp8x23_broadcast/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_fp8x23_broadcast/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_fp8x23_broadcast/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32_broadcast.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32_broadcast/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32_broadcast/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i32_broadcast/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8_broadcast.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8_broadcast/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8_broadcast/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_i8_broadcast/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32_broadcast.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32_broadcast/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32_broadcast/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/or_u32_broadcast/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16_broadcast.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16_broadcast/input_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16_broadcast/input_1.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp16x16_broadcast/output_0.cairo | 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())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/pow_fp8x23.cairo | 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);
}
| https://github.com/gizatechxyz/orion |
tests/numbers.cairo | // mod fixed_point;
mod complex_number_test;
| https://github.com/gizatechxyz/orion |
tests/numbers/complex_number_test.cairo | //use cubit::f128::types::fixed::FixedTrait;
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;
#[test]
#[available_gas(2000000000)]
fn test_add() {
// Test addition of two complex numbers
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'
);
}
#[test]
#[available_gas(2000000000)]
fn test_sub() {
// Test substraction of two complex numbers
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'
);
}
#[test]
#[available_gas(2000000000)]
fn test_mul() {
// Test multiplication of positive integers
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'
);
// Test multiplication with a pure imaginary number
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'
);
// Test multiplication by zero
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');
// Test i * i = -1
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');
}
#[test]
#[available_gas(2000000000)]
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'
);
}
#[test]
#[available_gas(2000000000)]
fn test_zero() {
// Test multiplication by 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');
}
#[test]
#[available_gas(2000000000)]
fn test_conjugate() {
// Test conjugate of a complex number
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'
);
}
#[test]
#[available_gas(2000000000)]
fn test_mag() {
// Test mag of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_arg() {
// Test arg of a complex number
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'
);
}
#[test]
#[available_gas(2000000000)]
fn test_exp() {
// Test exp of a complex number
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
); // 4 + 42i
let _z = ComplexTrait::exp(a);
let _z_expected: complex64 = ComplexTrait::new(
FixedTrait::new(402848450095324460000, true), FixedTrait::new(923082101320478400000, true)
);
}
#[test]
#[available_gas(2000000000)]
fn test_exp2() {
// Test exp2 of a complex number
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
); // 4 + 42i
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');
}
#[test]
#[available_gas(2000000000)]
fn test_sqrt() {
// Test square root of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_ln() {
// Test ln of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_log2() {
// Test log2 of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_log10() {
// Test log10 of a complex number
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'
);
}
#[test]
#[available_gas(2000000000)]
fn test_acos() {
// Test acos of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_asin() {
// Test asin of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_atan() {
// Test atan of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_cos() {
// Test cos of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_sin() {
// Test sin of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_tan() {
// Test tan of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_acosh() {
// Test acosh of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_asinh() {
// Test asinh of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_atanh() {
// Test atanh of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_cosh() {
// Test cosh of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_sinh() {
// Test sinh of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_tanh() {
// Test tanh of a complex number
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');
}
#[test]
#[available_gas(2000000000)]
fn test_pow() {
// Test pow with exp = 2
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');
// Test pow with exp = n, int
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');
// Test pow with exp = w, complex
let w: complex64 = ComplexTrait::new(
FixedTrait::new(36893488147419103232, false), FixedTrait::new(18446744073709551616, false)
); // 2 + i
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'
);
}
#[test]
#[available_gas(2000000000)]
fn test_to_polar() {
// Test to polar coordinates of a complex number
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
); // 4 + 42i
let (mag, arg) = a.to_polar();
assert(mag == FixedTrait::new(778268985067028086784, false), 'mag = 42.190046219457976');
assert(arg == FixedTrait::new(27224496882576083824, false), 'arg = 1.4758446204521403');
}
#[test]
#[available_gas(2000000000)]
fn test_from_polar() {
// Test from polar coordiantes of a complex number
let mag: FP64x64 = FixedTrait::new(778268985067028086784, false); // 42.190046219457976
let arg: FP64x64 = FixedTrait::new(27224496882576083824, false); //1.4758446204521403
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');
}
#[test]
#[available_gas(2000000000)]
fn test_reciprocal() {
// Test from polar coordiantes of a complex number
let a: complex64 = ComplexTrait::new(
FixedTrait::new(73786976294838206464, false), FixedTrait::new(774763251095801167872, false)
); // 4 + 42i
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');
}
| https://github.com/gizatechxyz/orion |
tests/numbers/fixed_point_test.cairo | mod erf_fp16x16_test;
mod erf_fp16x16wide_test;
mod erf_fp8x23_test;
mod erf_fp8x23wide_test;
mod erf_fp32x32_test;
mod erf_fp64x64_test;
| https://github.com/gizatechxyz/orion |
tests/numbers/fixed_point_test/erf_fp16x16_test.cairo | 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!');
}
| https://github.com/gizatechxyz/orion |
tests/numbers/fixed_point_test/erf_fp16x16wide_test.cairo | 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!');
}
| https://github.com/gizatechxyz/orion |
tests/numbers/fixed_point_test/erf_fp32x32_test.cairo | 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!');
}
| https://github.com/gizatechxyz/orion |
tests/numbers/fixed_point_test/erf_fp64x64_test.cairo | 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!');
}
| https://github.com/gizatechxyz/orion |
tests/numbers/fixed_point_test/erf_fp8x23_test.cairo | 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!');
}
| https://github.com/gizatechxyz/orion |
tests/numbers/fixed_point_test/erf_fp8x23wide_test.cairo | 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!');
}
| https://github.com/gizatechxyz/orion |
tests/operators.cairo | 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;
| https://github.com/gizatechxyz/orion |
tests/operators/constant_of_shape_test.cairo | 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');
}
| https://github.com/gizatechxyz/orion |
tests/operators/optional.cairo | mod optional_test;
mod optional_has_element_test;
mod optional_get_element_test;
| https://github.com/gizatechxyz/orion |
tests/operators/optional/optional_get_element_test.cairo | 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_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]');
}
#[test]
#[available_gas(200000000000)]
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]');
}
| https://github.com/gizatechxyz/orion |
tests/operators/optional/optional_has_element_test.cairo | 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');
}
| https://github.com/gizatechxyz/orion |
tests/operators/optional/optional_test.cairo | 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_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]'
);
}
#[test]
#[available_gas(200000000000)]
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]'
);
}
| https://github.com/gizatechxyz/orion |
tests/operators/qlinear_add_test.cairo | 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};
#[test]
#[available_gas(200000000000)]
fn qlinearadd_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 b = TensorTrait::<
i8
>::new(
shape: array![4, 2].span(),
data: array![2_i8, 4_i8, 6_i8, 8_i8, 10_i8, 12_i8, 14_i8, 16_i8].span(),
);
let a_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(20000, false)].span(),);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(25000, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(30000, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = a
.qlinear_add(@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point);
assert((*actual_output.data[0]).into() == 2, '*result[0] == 2');
assert((*actual_output.data[1]).into() == 4, '*result[1] == 4');
assert((*actual_output.data[2]).into() == 7, '*result[2] == 7');
assert((*actual_output.data[3]).into() == 9, '*result[3] == 9');
assert((*actual_output.data[4]).into() == 11, '*result[4] == 11');
assert((*actual_output.data[5]).into() == 14, '*result[5] == 14');
assert((*actual_output.data[6]).into() == 16, '*result[6] == 16');
assert((*actual_output.data[7]).into() == 18, '*result[7] == 18');
}
#[test]
#[available_gas(200000000000)]
fn qlinearadd_broadcast_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![2, 4].span(),
data: array![1_i8, 2_i8, 3_i8, 4_i8, 5_i8, 6_i8, 7_i8, 8_i8].span(),
);
let b = TensorTrait::<
i8
>::new(shape: array![1, 4].span(), data: array![2_i8, 4_i8, 6_i8, 8_i8,].span(),);
let a_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(20000, false)].span(),);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(25000, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(30000, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = a
.qlinear_add(@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point);
assert((*actual_output.data[0]).into() == 2, '*result[0] == 2');
assert((*actual_output.data[1]).into() == 4, '*result[1] == 4');
assert((*actual_output.data[2]).into() == 7, '*result[2] == 7');
assert((*actual_output.data[3]).into() == 9, '*result[3] == 9');
assert((*actual_output.data[4]).into() == 5, '*result[4] == 5');
assert((*actual_output.data[5]).into() == 7, '*result[5] == 7');
assert((*actual_output.data[6]).into() == 9, '*result[6] == 9');
assert((*actual_output.data[7]).into() == 12, '*result[7] == 12');
}
#[test]
#[available_gas(200000000000)]
fn test_example_doc() {
let a = TensorTrait::<
i8
>::new(shape: array![2, 3].span(), data: array![6_i8, 6_i8, 6_i8, 11_i8, 11_i8, 11_i8].span(),);
let b = TensorTrait::<
i8
>::new(shape: array![1, 3].span(), data: array![40_i8, 40_i8, 40_i8].span(),);
let a_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(131072, false)].span(),
);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(16384, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(655360, false)].span(),
);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, true)].span(),);
let actual_output = a
.qlinear_add(@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point);
assert((*actual_output.data[0]).into() == 1, '*result[0] == 1');
assert((*actual_output.data[1]).into() == 1, '*result[1] == 1');
assert((*actual_output.data[2]).into() == 1, '*result[2] == 1');
assert((*actual_output.data[3]).into() == 2, '*result[3] == 2');
assert((*actual_output.data[4]).into() == 2, '*result[4] == 2');
assert((*actual_output.data[5]).into() == 2, '*result[5] == 2');
}
| https://github.com/gizatechxyz/orion |
tests/operators/qlinear_concat_test.cairo | 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};
fn print_span(mut span: Span<i8>) {
loop {
match span.pop_front() {
Option::Some(i) => { (*i).print(); },
Option::None => { break; }
};
};
}
#[test]
#[available_gas(200000000000)]
fn qlinear_concat_test() {
let tensor1 = TensorTrait::<
i8
>::new(shape: array![2, 2].span(), data: array![10_i8, 20_i8, 30_i8, 40_i8,].span(),);
let tensor2 = TensorTrait::<
i8
>::new(shape: array![2, 2].span(), data: array![20_i8, 40_i8, 60_i8, 80_i8,].span(),);
let tensors = array![tensor1, tensor2].span();
let tensor1_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(20000, false)].span(),);
let tensor2_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(25000, false)].span(),);
let scales = array![tensor1_scale, tensor2_scale].span();
let tensor1_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let tensor2_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let zero_points = array![tensor1_zero_point, tensor2_zero_point].span();
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = TensorTrait::qlinear_concat(
tensors, scales, zero_points, @y_scale, @y_zero_point, 0
);
assert((*actual_output.data[0]).into() == 3, '*result[0] == 3');
assert((*actual_output.data[1]).into() == 6, '*result[1] == 6');
assert((*actual_output.data[2]).into() == 9, '*result[2] == 9');
assert((*actual_output.data[3]).into() == 12, '*result[3] == 12');
assert((*actual_output.data[4]).into() == 7, '*result[4] == 8');
assert((*actual_output.data[5]).into() == 15, '*result[5] == 15');
assert((*actual_output.data[6]).into() == 22, '*result[6] == 22');
assert((*actual_output.data[7]).into() == 30, '*result[7] == 30');
}
#[test]
#[available_gas(200000000000)]
fn qlinear_concat_test_shape() {
let tensor1 = TensorTrait::<
i8
>::new(shape: array![2, 2].span(), data: array![2_i8, 2_i8, 2_i8, 2_i8,].span(),);
let tensor2 = TensorTrait::<
i8
>::new(shape: array![2, 2].span(), data: array![8_i8, 8_i8, 8_i8, 8_i8,].span(),);
let tensor3 = TensorTrait::<
i8
>::new(shape: array![2, 2].span(), data: array![10_i8, 10_i8, 10_i8, 10_i8,].span(),);
let tensors = array![tensor1, tensor2, tensor3].span();
let tensor1_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(131072, false)].span(),
);
let tensor2_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(262144, false)].span(),
);
let tensor3_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let scales = array![tensor1_scale, tensor2_scale, tensor3_scale].span();
let tensor1_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let tensor2_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let tensor3_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let zero_points = array![tensor1_zero_point, tensor2_zero_point, tensor3_zero_point].span();
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(30000, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = TensorTrait::qlinear_concat(
tensors, scales, zero_points, @y_scale, @y_zero_point, 0
);
assert((*actual_output.shape[0]).into() == 6, '*result.shape[0] == 6');
assert((*actual_output.shape[1]).into() == 2, '*result.shape[1] == 2');
}
#[test]
#[available_gas(200000000000)]
fn qlinear_concat_example_doc() {
let tensor1 = TensorTrait::<
i8
>::new(shape: array![2, 2].span(), data: array![5_i8, 5_i8, 5_i8, 5_i8,].span(),);
let tensor2 = TensorTrait::<
i8
>::new(shape: array![2, 2].span(), data: array![1_i8, 1_i8, 1_i8, 1_i8,].span(),);
let tensors = array![tensor1, tensor2].span();
let tensor1_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(131072, false)].span(),
);
let tensor2_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(262144, false)].span(),
);
let scales = array![tensor1_scale, tensor2_scale].span();
let tensor1_zero_point = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(327680, false)].span(),
);
let tensor2_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let zero_points = array![tensor1_zero_point, tensor2_zero_point].span();
let y_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(262144, false)].span(),
);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let actual_output = TensorTrait::qlinear_concat(
tensors, scales, zero_points, @y_scale, @y_zero_point, 0
);
assert((*actual_output.data[0]).into() == 1, '*result[0] == 1');
assert((*actual_output.data[1]).into() == 1, '*result[1] == 1');
assert((*actual_output.data[2]).into() == 1, '*result[2] == 1');
assert((*actual_output.data[3]).into() == 1, '*result[3] == 1');
assert((*actual_output.data[4]).into() == 2, '*result[4] == 2');
assert((*actual_output.data[5]).into() == 2, '*result[5] == 2');
assert((*actual_output.data[6]).into() == 2, '*result[4] == 2');
assert((*actual_output.data[7]).into() == 2, '*result[5] == 2');
}
| https://github.com/gizatechxyz/orion |
tests/operators/qlinear_leakyrelu_test.cairo | 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};
#[test]
#[available_gas(200000000000)]
fn qlinear_leakyrelu_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![2, 3].span(),
data: array![-10_i8, -10_i8, -10_i8, 10_i8, 10_i8, 10_i8].span(),
);
let a_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(131072, false)].span(),
);
let a_zero_point = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(131072, false)].span(),
);
let alpha = FixedTrait::<FP16x16>::new(655360, false);
let actual_output = a.qlinear_leakyrelu(@a_scale, @a_zero_point, alpha);
assert((*actual_output.data[0]).abs().into() == 118, '*result[0] == 118');
assert((*actual_output.data[1]).abs().into() == 118, '*result[1] == 118');
assert((*actual_output.data[2]).abs().into() == 118, '*result[2] == 118');
assert((*actual_output.data[3]).into() == 10, '*result[3] == 10');
assert((*actual_output.data[4]).into() == 10, '*result[4] == 10');
assert((*actual_output.data[5]).into() == 10, '*result[5] == 10');
}
| https://github.com/gizatechxyz/orion |
tests/operators/qlinear_matmul_test.cairo | use core::debug::PrintTrait;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{
TensorTrait, Tensor, I8Tensor, I32Tensor, U32Tensor, FP16x16Tensor, FP32x32Tensor
};
use orion::numbers::{FP16x16, FP16x16Impl, FP32x32, FP32x32Impl, FixedTrait};
use orion::numbers::{NumberTrait};
#[test]
#[available_gas(200000000000)]
fn qlinearmatmul_2D_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![2, 4].span(),
data: array![1_i8, 2_i8, 3_i8, 4_i8, 5_i8, 6_i8, 7_i8, 8_i8].span(),
);
let b = TensorTrait::<
i8
>::new(
shape: array![4, 3].span(),
data: array![2_i8, 4_i8, 6_i8, 8_i8, 10_i8, 12_i8, 14_i8, 16_i8, 18_i8, 20_i8, 22_i8, 24_i8]
.span(),
);
let a_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(2000, false)].span(),);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(2500, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(3000, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = a
.qlinear_matmul(
@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point
);
assert((*actual_output.data[0]).into() == 3, '*result[0] == 3');
assert((*actual_output.data[1]).into() == 4, '*result[1] == 4');
assert((*actual_output.data[2]).into() == 4, '*result[2] == 4');
assert((*actual_output.data[3]).into() == 8, '*result[3] == 8');
assert((*actual_output.data[4]).into() == 9, '*result[4] == 9');
assert((*actual_output.data[5]).into() == 10, '*result[5] == 10');
}
#[test]
#[available_gas(200000000000)]
fn qlinearmatmul_3D_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![2, 2, 3].span(),
data: array![
-1_i8, -2_i8, -2_i8, -3_i8, -4_i8, -4_i8, -5_i8, -6_i8, -6_i8, -7_i8, -8_i8, -8_i8
]
.span(),
);
let b = TensorTrait::<
i8
>::new(
shape: array![2, 3, 2].span(),
data: array![
-2_i8, -4_i8, -6_i8, -8_i8, -10_i8, -12_i8, -2_i8, -4_i8, -6_i8, -8_i8, -10_i8, -12_i8
]
.span(),
);
let a_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(20000, false)].span(),);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(25000, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(30000, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = a
.qlinear_matmul(
@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point
);
assert((*actual_output.data[0]).into() == 8, '*result[0] == 8');
assert((*actual_output.data[1]).into() == 11, '*result[1] == 11');
assert((*actual_output.data[2]).into() == 17, '*result[2] == 17');
assert((*actual_output.data[3]).into() == 23, '*result[3] == 23');
assert((*actual_output.data[4]).into() == 26, '*result[4] == 26');
assert((*actual_output.data[5]).into() == 35, '*result[5] == 35');
assert((*actual_output.data[6]).into() == 36, '*result[6] == 36');
assert((*actual_output.data[7]).into() == 47, '*result[7] == 47');
}
#[test]
#[available_gas(200000000000)]
fn test_example_doc() {
let a = TensorTrait::<
i8
>::new(shape: array![2, 3].span(), data: array![3_i8, 4_i8, 5_i8, 2_i8, 4_i8, 3_i8].span(),);
let b = TensorTrait::<
i8
>::new(shape: array![3, 1].span(), data: array![4_i8, 8_i8, 4_i8].span(),);
let a_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(131072, false)].span(),
);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(16384, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(393216, false)].span(),
);
let y_zero_point = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(655360, false)].span(),
);
let actual_output = a
.qlinear_matmul(
@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point
);
assert((*actual_output.data[0]).into() == 14, '*result[0] == 14');
assert((*actual_output.data[1]).into() == 13, '*result[1] == 13');
}
fn print_span(mut span: Span<i8>) {
loop {
match span.pop_front() {
Option::Some(i) => { (*i).print(); },
Option::None => { break; }
};
};
}
| https://github.com/gizatechxyz/orion |
tests/operators/qlinear_mul_test.cairo | use core::debug::PrintTrait;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{
TensorTrait, Tensor, I8Tensor, I32Tensor, U32Tensor, FP16x16Tensor, FP32x32Tensor
};
use orion::numbers::{FP16x16, FP16x16Impl, FP32x32, FP32x32Impl, FixedTrait};
use orion::numbers::{NumberTrait};
#[test]
#[available_gas(200000000000)]
fn qlinearmul_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![4, 3].span(),
data: array![1_i8, 2_i8, 3_i8, 4_i8, 5_i8, 6_i8, 7_i8, 8_i8, 9_i8, 10_i8, 11_i8, 12_i8]
.span(),
);
let b = TensorTrait::<
i8
>::new(
shape: array![4, 3].span(),
data: array![2_i8, 4_i8, 6_i8, 8_i8, 10_i8, 12_i8, 14_i8, 16_i8, 18_i8, 20_i8, 22_i8, 24_i8]
.span(),
);
let a_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(2000, false)].span(),);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(2500, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(3000, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = a
.qlinear_mul(@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point);
assert((*actual_output.data[0]).into() == 0, '*result[0] == 0');
assert((*actual_output.data[1]).into() == 0, '*result[1] == 0');
assert((*actual_output.data[2]).into() == 0, '*result[2] == 0');
assert((*actual_output.data[3]).into() == 0, '*result[3] == 0');
assert((*actual_output.data[4]).into() == 1, '*result[4] == 1');
assert((*actual_output.data[5]).into() == 1, '*result[5] == 1');
assert((*actual_output.data[6]).into() == 2, '*result[6] == 2');
assert((*actual_output.data[7]).into() == 3, '*result[7] == 3');
assert((*actual_output.data[8]).into() == 4, '*result[8] == 4');
assert((*actual_output.data[9]).into() == 5, '*result[9] == 5');
assert((*actual_output.data[10]).into() == 6, '*result[10] == 6');
assert((*actual_output.data[11]).into() == 7, '*result[11] == 7');
}
#[test]
#[available_gas(200000000000)]
fn qlinear_mul_broadcast_test() {
let a = TensorTrait::<
i8
>::new(
shape: array![2, 4].span(),
data: array![1_i8, 2_i8, 3_i8, 4_i8, 5_i8, 6_i8, 7_i8, 8_i8].span(),
);
let b = TensorTrait::<
i8
>::new(shape: array![1, 4].span(), data: array![2_i8, 4_i8, 6_i8, 8_i8,].span(),);
let a_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(20000, false)].span(),);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(25000, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(30000, false)].span(),);
let y_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let actual_output = a
.qlinear_mul(@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point);
assert((*actual_output.data[0]).into() == 0, '*result[0] == 0');
assert((*actual_output.data[1]).into() == 2, '*result[1] == 2');
assert((*actual_output.data[2]).into() == 4, '*result[2] == 4');
assert((*actual_output.data[3]).into() == 8, '*result[3] == 8');
assert((*actual_output.data[4]).into() == 2, '*result[4] == 2');
assert((*actual_output.data[5]).into() == 6, '*result[5] == 6');
assert((*actual_output.data[6]).into() == 10, '*result[6] == 10');
assert((*actual_output.data[7]).into() == 16, '*result[7] == 16');
}
#[test]
#[available_gas(200000000000)]
fn test_example_doc() {
let a = TensorTrait::<
i8
>::new(
shape: array![2, 3].span(), data: array![21_i8, 21_i8, 21_i8, 41_i8, 41_i8, 41_i8].span(),
);
let b = TensorTrait::<
i8
>::new(shape: array![1, 3].span(), data: array![4_i8, 8_i8, 12_i8].span(),);
let a_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(131072, false)].span(),
);
let a_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(65536, false)].span(),);
let b_scale = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(16384, false)].span(),);
let b_zero_point = TensorTrait::<
FP16x16
>::new(shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(0, false)].span(),);
let y_scale = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(393216, false)].span(),
);
let y_zero_point = TensorTrait::<
FP16x16
>::new(
shape: array![1].span(), data: array![FixedTrait::<FP16x16>::new(655360, false)].span(),
);
let actual_output = a
.qlinear_mul(@a_scale, @a_zero_point, @b, @b_scale, @b_zero_point, @y_scale, @y_zero_point);
assert((*actual_output.data[0]).into() == 16, '*result[0] == 16');
assert((*actual_output.data[1]).into() == 23, '*result[1] == 23');
assert((*actual_output.data[2]).into() == 30, '*result[2] == 30');
assert((*actual_output.data[3]).into() == 23, '*result[3] == 23');
assert((*actual_output.data[4]).into() == 36, '*result[4] == 36');
assert((*actual_output.data[5]).into() == 50, '*result[5] == 50');
}
| https://github.com/gizatechxyz/orion |
tests/operators/tensor/math.cairo | mod argmax;
mod argmin;
mod max;
mod min;
mod reduce_sum;
mod exp;
mod equal;
mod greater;
mod greater_equal;
mod less;
mod less_equal;
mod abs;
mod ceil;
mod ln;
mod arithmetic;
mod sin;
mod cos;
mod asin;
mod cumsum;
mod flatten;
mod sinh;
mod tanh;
mod cosh;
mod acosh;
mod asinh;
mod atan;
mod xor;
mod or;
mod acos;
mod onehot;
mod sqrt;
mod concat;
mod gather;
mod where;
| https://github.com/gizatechxyz/orion |
tests/operators/transpose_test.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor, U32Tensor};
use core::debug::PrintTrait;
#[test]
#[available_gas(200000000000)]
fn transpose_test_shape() {
let tensor = TensorTrait::<
u32
>::new(shape: array![4, 2].span(), data: array![0, 1, 2, 3, 4, 5, 6, 7].span(),);
let result = tensor.transpose(axes: array![1, 0].span());
assert(result.shape == array![2, 4].span(), 'wrong dim');
}
#[test]
#[available_gas(200000000000)]
fn transpose_test_values() {
let tensor = TensorTrait::<
u32
>::new(shape: array![4, 2].span(), data: array![0, 1, 2, 3, 4, 5, 6, 7].span(),);
let result = tensor.transpose(axes: array![1, 0].span());
assert(result.data == array![0, 2, 4, 6, 1, 3, 5, 7].span(), 'wrong data');
}
#[test]
#[available_gas(200000000000)]
fn transpose_test_1D() {
let tensor = TensorTrait::<u32>::new(shape: array![4].span(), data: array![0, 1, 2, 3].span(),);
let result = tensor.transpose(axes: array![0].span());
assert(result.shape == array![4].span(), 'wrong shape');
assert(result.data == array![0, 1, 2, 3].span(), 'wrong data');
}
#[test]
#[available_gas(200000000000)]
fn transpose_test_3D() {
let tensor = TensorTrait::<
u32
>::new(shape: array![2, 2, 2].span(), data: array![0, 1, 2, 3, 4, 5, 6, 7].span(),);
let result = tensor.transpose(axes: array![1, 2, 0].span());
assert(result.shape == array![2, 2, 2].span(), 'wrong shape');
assert(result.data == array![0, 4, 1, 5, 2, 6, 3, 7].span(), 'wrong data');
}
| https://github.com/gizatechxyz/orion |
tests/performance.cairo | mod quantize_linear_test;
mod dequantize_linear_test;
mod dynamic_quantize_linear_test;
| https://github.com/gizatechxyz/orion |
tests/performance/dequantize_linear_test.cairo | mod dequantize_linear_i32_test;
mod dequantize_linear_fp_test;
| https://github.com/gizatechxyz/orion |
tests/performance/dequantize_linear_test/dequantize_linear_fp_test.cairo | mod fp_i8_test;
| https://github.com/gizatechxyz/orion |
tests/performance/dequantize_linear_test/dequantize_linear_fp_test/fp_i8_test.cairo | #[cfg(test)]
mod fp8x23 {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use core::debug::PrintTrait;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp8x23::core::{FP8x23Impl, FP8x23PartialEq};
use orion::operators::tensor::I8Tensor;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::FP8x23;
#[test]
#[available_gas(2000000)]
fn dequantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::<i8>::new();
data.append(0);
data.append(3);
data.append(125);
data.append(127);
let x = TensorTrait::new(shape.span(), data.span());
// XSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(2, false));
let x_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(0, false));
let x_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<FP8x23> = x.dequantize_linear(@x_scale, @x_zero_point);
assert(
(*y.data[0]).into() == FixedTrait::<FP8x23, u32>::new_unscaled(0, false),
'*result[0] == 0'
);
assert(
(*y.data[1]).into() == FixedTrait::<FP8x23, u32>::new_unscaled(6, false),
'*result[1] == 6'
);
assert(
(*y.data[2]).into() == FixedTrait::<FP8x23, u32>::new_unscaled(250, false),
'*result[2] == 250'
);
assert(
(*y.data[3]).into() == FixedTrait::<FP8x23, u32>::new_unscaled(254, false),
'*result[3] == 254'
);
}
// TODO: fix it when move performance tests in nodes.
// #[test]
// #[available_gas(20000000)]
// fn per_axis() {
// // X
// let mut shape = ArrayTrait::<usize>::new();
// shape.append(1);
// shape.append(3);
// shape.append(3);
// shape.append(2);
// let mut data = ArrayTrait::<i8>::new();
// data.append(IntegerTrait::new(3, false));
// data.append(IntegerTrait::new(89, false));
// data.append(IntegerTrait::new(34, false));
// data.append(IntegerTrait::new(127, false));
// data.append(IntegerTrait::new(74, false));
// data.append(IntegerTrait::new(59, false));
// data.append(IntegerTrait::new(5, false));
// data.append(IntegerTrait::new(24, false));
// data.append(IntegerTrait::new(24, false));
// data.append(IntegerTrait::new(87, false));
// data.append(IntegerTrait::new(32, false));
// data.append(IntegerTrait::new(13, false));
// data.append(IntegerTrait::new(127, false));
// data.append(IntegerTrait::new(99, false));
// data.append(IntegerTrait::new(4, false));
// data.append(IntegerTrait::new(127, false));
// data.append(IntegerTrait::new(121, false));
// data.append(IntegerTrait::new(102, false));
//
// let x = TensorTrait::new(shape.span(), data.span());
// // XSCALE
// let mut shape = ArrayTrait::<usize>::new();
// shape.append(1);
// shape.append(3);
// shape.append(1);
// shape.append(1);
// let mut data = ArrayTrait::<FixedType>::new();
// data.append(FixedTrait::new_unscaled(2, false));
// data.append(FixedTrait::new_unscaled(4, false));
// data.append(FixedTrait::new_unscaled(5, false));
//
// let x_scale = TensorTrait::new(shape.span(), data.span());
// // ZEROPOINT
// let mut shape = ArrayTrait::<usize>::new();
// shape.append(1);
// shape.append(3);
// shape.append(1);
// shape.append(1);
// let mut data = ArrayTrait::<FixedType>::new();
// data.append(FixedTrait::new_unscaled(1, false));
// data.append(FixedTrait::new_unscaled(2, false));
// data.append(FixedTrait::new_unscaled(3, false));
//
// let x_zero_point = TensorTrait::new(shape.span(), data.span());
// let y: Tensor<FixedType> = x.dequantize_linear(@x_scale, @x_zero_point);
// assert((*y.data[0]).into() == FixedTrait::new_unscaled(4, false), '*result[0] == 162');
// assert((*y.data[1]).into() == FixedTrait::new_unscaled(176, false), '*result[1] == 10');
// assert((*y.data[2]).into() == FixedTrait::new_unscaled(66, false), '*result[2] == 100');
// assert((*y.data[3]).into() == FixedTrait::new_unscaled(252, false), '*result[3] == 232');
// assert((*y.data[4]).into() == FixedTrait::new_unscaled(146, false), '*result[4] == 20');
// assert((*y.data[5]).into() == FixedTrait::new_unscaled(116, false), '*result[5] == 50');
// assert((*y.data[6]).into() == FixedTrait::new_unscaled(12, false), '*result[6] == 76');
// assert((*y.data[7]).into() == FixedTrait::new_unscaled(88, false), '*result[7] == 0');
// assert((*y.data[8]).into() == FixedTrait::new_unscaled(88, false), '*result[8] == 0');
// assert((*y.data[9]).into() == FixedTrait::new_unscaled(340, false), '*result[9] == 252');
// assert((*y.data[10]).into() == FixedTrait::new_unscaled(120, false), '*result[10] == 32');
// assert((*y.data[11]).into() == FixedTrait::new_unscaled(44, false), '*result[11] == 44');
// assert((*y.data[12]).into() == FixedTrait::new_unscaled(620, false), '*result[12] == 245');
// assert((*y.data[13]).into() == FixedTrait::new_unscaled(480, false), '*result[13] == 485');
// assert((*y.data[14]).into() == FixedTrait::new_unscaled(5, false), '*result[14] == 960');
// assert((*y.data[15]).into() == FixedTrait::new_unscaled(620, false), '*result[15] == 270');
// assert((*y.data[16]).into() == FixedTrait::new_unscaled(590, false), '*result[16] == 375');
// assert((*y.data[17]).into() == FixedTrait::new_unscaled(495, false), '*result[17] == 470');
// }
}
#[cfg(test)]
mod fp16x16 {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use core::debug::PrintTrait;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp16x16::core::{
FP16x16Impl, FP16x16PartialEq
};
use orion::operators::tensor::I8Tensor;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::FP16x16;
#[test]
#[available_gas(2000000)]
fn dequantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::<i8>::new();
data.append(0);
data.append(3);
data.append(125);
data.append(127);
let x = TensorTrait::new(shape.span(), data.span());
// XSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(2, false));
let x_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(0, false));
let x_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<FP16x16> = x.dequantize_linear(@x_scale, @x_zero_point);
assert(
(*y.data[0]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(0, false),
'*result[0] == 0'
);
assert(
(*y.data[1]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(6, false),
'*result[1] == 6'
);
assert(
(*y.data[2]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(250, false),
'*result[2] == 250'
);
assert(
(*y.data[3]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(254, false),
'*result[3] == 254'
);
}
#[test]
#[available_gas(20000000)]
fn per_axis() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::<i8>::new();
data.append(3);
data.append(89);
data.append(34);
data.append(127);
data.append(74);
data.append(59);
data.append(5);
data.append(24);
data.append(24);
data.append(87);
data.append(32);
data.append(13);
data.append(127);
data.append(99);
data.append(4);
data.append(127);
data.append(121);
data.append(102);
let x = TensorTrait::new(shape.span(), data.span());
// XSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(4, false));
data.append(FixedTrait::new_unscaled(5, false));
let x_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
let x_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<FP16x16> = x.dequantize_linear(@x_scale, @x_zero_point);
assert(
(*y.data[0]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(4, false),
'*result[0] == 162'
);
assert(
(*y.data[1]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(176, false),
'*result[1] == 10'
);
assert(
(*y.data[2]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(66, false),
'*result[2] == 100'
);
assert(
(*y.data[3]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(252, false),
'*result[3] == 232'
);
assert(
(*y.data[4]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(146, false),
'*result[4] == 20'
);
assert(
(*y.data[5]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(116, false),
'*result[5] == 50'
);
assert(
(*y.data[6]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(12, false),
'*result[6] == 76'
);
assert(
(*y.data[7]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(88, false),
'*result[7] == 0'
);
assert(
(*y.data[8]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(88, false),
'*result[8] == 0'
);
assert(
(*y.data[9]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(340, false),
'*result[9] == 252'
);
assert(
(*y.data[10]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(120, false),
'*result[10] == 32'
);
assert(
(*y.data[11]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(44, false),
'*result[11] == 44'
);
assert(
(*y.data[12]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(620, false),
'*result[12] == 245'
);
assert(
(*y.data[13]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(480, false),
'*result[13] == 485'
);
assert(
(*y.data[14]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(5, false),
'*result[14] == 960'
);
assert(
(*y.data[15]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(620, false),
'*result[15] == 270'
);
assert(
(*y.data[16]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(590, false),
'*result[16] == 375'
);
assert(
(*y.data[17]).into() == FixedTrait::<FP16x16, u32>::new_unscaled(495, false),
'*result[17] == 470'
);
}
}
| https://github.com/gizatechxyz/orion |
tests/performance/dequantize_linear_test/dequantize_linear_i32_test.cairo | use core::debug::{PrintTrait};
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::operators::tensor::I8Tensor;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000)]
fn dequantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::<i8>::new();
data.append(0);
data.append(3);
data.append(125);
data.append(127);
let x = TensorTrait::new(shape.span(), data.span());
// XSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(2);
let x_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(0);
let x_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i32> = x.dequantize_linear(@x_scale, @x_zero_point);
assert((*y.data[0]).into() == 0, '*result[0] == 0');
assert((*y.data[1]).into() == 6, '*result[1] == 6');
assert((*y.data[2]).into() == 250, '*result[2] == 250');
assert((*y.data[3]).into() == 254, '*result[3] == 254');
}
#[test]
#[available_gas(20000000)]
fn per_axis() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::<i8>::new();
data.append(3);
data.append(89);
data.append(34);
data.append(127);
data.append(74);
data.append(59);
data.append(5);
data.append(24);
data.append(24);
data.append(87);
data.append(32);
data.append(13);
data.append(127);
data.append(99);
data.append(4);
data.append(127);
data.append(121);
data.append(102);
let x = TensorTrait::new(shape.span(), data.span());
// XSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(2);
data.append(4);
data.append(5);
let x_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(1);
data.append(2);
data.append(3);
let x_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i32> = x.dequantize_linear(@x_scale, @x_zero_point);
assert((*y.data[0]).into() == 4, '*result[0] == 162');
assert((*y.data[1]).into() == 176, '*result[1] == 10');
assert((*y.data[2]).into() == 66, '*result[2] == 100');
assert((*y.data[3]).into() == 252, '*result[3] == 232');
assert((*y.data[4]).into() == 146, '*result[4] == 20');
assert((*y.data[5]).into() == 116, '*result[5] == 50');
assert((*y.data[6]).into() == 12, '*result[6] == 76');
assert((*y.data[7]).into() == 88, '*result[7] == 0');
assert((*y.data[8]).into() == 88, '*result[8] == 0');
assert((*y.data[9]).into() == 340, '*result[9] == 252');
assert((*y.data[10]).into() == 120, '*result[10] == 32');
assert((*y.data[11]).into() == 44, '*result[11] == 44');
assert((*y.data[12]).into() == 620, '*result[12] == 245');
assert((*y.data[13]).into() == 480, '*result[13] == 485');
assert((*y.data[14]).into() == 5, '*result[14] == 960');
assert((*y.data[15]).into() == 620, '*result[15] == 270');
assert((*y.data[16]).into() == 590, '*result[16] == 375');
assert((*y.data[17]).into() == 495, '*result[17] == 470');
}
| https://github.com/gizatechxyz/orion |
tests/performance/dynamic_quantize_linear_test.cairo | mod dynamic_quantize_linear_fp_test;
| https://github.com/gizatechxyz/orion |
tests/performance/dynamic_quantize_linear_test/dynamic_quantize_linear_fp_test.cairo | #[cfg(test)]
mod fp8x23 {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use core::debug::PrintTrait;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::FP8x23;
#[test]
#[available_gas(2000000)]
fn dynamic_quantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new(0, false));
data.append(FixedTrait::new(587203, false)); // 0.07
data.append(FixedTrait::new(838861, false)); // 0.1
data.append(FixedTrait::new(1677722, false)); // 0.2
data.append(FixedTrait::new(4194304, false)); // 0.5
data.append(FixedTrait::new(7549747, false)); // 0.9
let x = TensorTrait::new(shape.span(), data.span());
let (y, y_scale, y_zero_point) = x.dynamic_quantize_linear();
assert((*(y_scale.data).at(0)).into() == 29606, '*y_scale[0].mag == 0.00353');
assert((*(y_zero_point.data).at(0)).into() == 0, '*y_zero_point[0].mag == 0');
assert((*(y.data).at(0)).into() == 0, '*result[0] == 0');
assert((*(y.data).at(1)).into() == 19, '*result[1] == 19');
assert((*(y.data).at(2)).into() == 28, '*result[2] == 28');
assert((*(y.data).at(3)).into() == 56, '*result[3] == 56');
assert((*(y.data).at(4)).into() == 141, '*result[4] == 141');
assert((*(y.data).at(5)).into() == 255, '*result[5] == 255');
}
}
#[cfg(test)]
mod fp16x16 {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use core::debug::PrintTrait;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::FP16x16;
#[test]
#[available_gas(2000000)]
fn dynamic_quantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new(10945, false)); // 0.167
data.append(FixedTrait::new(190054, false)); // 2.9
data.append(FixedTrait::new_unscaled(3, false)); // 3.0
data.append(FixedTrait::new(229376, false)); // 3.5
data.append(FixedTrait::new_unscaled(3, true)); // -3.0
data.append(FixedTrait::new(229376, true)); // -3.5
let x = TensorTrait::new(shape.span(), data.span());
let (y, y_scale, y_zero_point) = x.dynamic_quantize_linear();
assert((*(y_scale.data).at(0)).into() == 1799, '*y_scale[0].mag == 0.02745');
assert((*(y_zero_point.data).at(0)).into() == 8355967, '*y_zero_point[0].mag == 128');
assert((*(y.data).at(0)).into() == 133, '*result[0] == 134');
assert((*(y.data).at(1)).into() == 233, '*result[1] == 233');
assert((*(y.data).at(2)).into() == 236, '*result[2] == 237');
assert((*(y.data).at(3)).into() == 255, '*result[3] == 255');
assert((*(y.data).at(4)).into() == 18, '*result[4] == -18');
assert((*(y.data).at(5)).into() == 0, '*result[5] == -0');
}
}
| https://github.com/gizatechxyz/orion |
tests/performance/quantize_linear_test.cairo | mod quantize_linear_i32_test;
mod quantize_linear_fp_test;
| https://github.com/gizatechxyz/orion |
tests/performance/quantize_linear_test/quantize_linear_fp_test.cairo | mod fp_i8_test;
| https://github.com/gizatechxyz/orion |
tests/performance/quantize_linear_test/quantize_linear_fp_test/fp_i8_test.cairo | #[cfg(test)]
mod fp8x23 {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use core::debug::PrintTrait;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::FP8x23;
#[test]
#[available_gas(2000000)]
fn quantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(200, false));
data.append(FixedTrait::new_unscaled(250, true));
data.append(FixedTrait::new_unscaled(100, true));
let x = TensorTrait::new(shape.span(), data.span());
// YSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(2, false));
let y_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(1, false));
let y_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i8> = x.quantize_linear(@y_scale, @y_zero_point);
assert((*y.data[0]).into() == 1, '*result[0] == 1');
assert((*y.data[1]).into() == 2, '*result[1] == 2');
assert((*y.data[2]).into() == 2, '*result[2] == 2');
assert((*y.data[3]).into() == 101, '*result[3] == 101');
assert((*y.data[4]).into() == -124, '*result[4] == -124');
assert((*y.data[5]).into() == -49, '*result[5] == -49');
}
#[test]
#[available_gas(20000000)]
fn per_axis() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(162, true));
data.append(FixedTrait::new_unscaled(10, false));
data.append(FixedTrait::new_unscaled(100, true));
data.append(FixedTrait::new_unscaled(232, false));
data.append(FixedTrait::new_unscaled(20, true));
data.append(FixedTrait::new_unscaled(50, true));
data.append(FixedTrait::new_unscaled(76, true));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(252, false));
data.append(FixedTrait::new_unscaled(32, false));
data.append(FixedTrait::new_unscaled(44, true));
data.append(FixedTrait::new_unscaled(245, false));
data.append(FixedTrait::new_unscaled(220, true));
data.append(FixedTrait::new_unscaled(210, true));
data.append(FixedTrait::new_unscaled(210, true));
data.append(FixedTrait::new_unscaled(200, true));
data.append(FixedTrait::new_unscaled(120, true));
let x = TensorTrait::new(shape.span(), data.span());
// YSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(4, false));
data.append(FixedTrait::new_unscaled(5, false));
let y_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<FP8x23>::new();
data.append(FixedTrait::new_unscaled(84, false));
data.append(FixedTrait::new_unscaled(24, false));
data.append(FixedTrait::new_unscaled(196, false));
let y_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i8> = x.quantize_linear(@y_scale, @y_zero_point);
assert((*y.data[0]).into() == 3, '*result[0] == 3');
assert((*y.data[1]).into() == 89, '*result[1] == 89');
assert((*y.data[2]).into() == 34, '*result[2] == 34');
assert((*y.data[3]).into() == 127, '*result[3] == 127');
assert((*y.data[4]).into() == 74, '*result[4] == 74');
assert((*y.data[5]).into() == 59, '*result[5] == 59');
assert((*y.data[6]).into() == 5, '*result[6] == 5');
assert((*y.data[7]).into() == 24, '*result[7] == 24');
assert((*y.data[8]).into() == 24, '*result[8] == 24');
assert((*y.data[9]).into() == 87, '*result[9] == 87');
assert((*y.data[10]).into() == 32, '*result[10] == 32');
assert((*y.data[11]).into() == 13, '*result[11] == 13');
assert((*y.data[12]).into() == 127, '*result[12] == 127');
assert((*y.data[13]).into() == 127, '*result[13] == 127');
assert((*y.data[14]).into() == 127, '*result[14] == 127');
assert((*y.data[15]).into() == 127, '*result[15] == 127');
assert((*y.data[16]).into() == 127, '*result[16] == 127');
assert((*y.data[17]).into() == 127, '*result[17] == 127');
}
}
#[cfg(test)]
mod fp16x16 {
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use core::debug::PrintTrait;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::FP16x16;
#[test]
#[available_gas(2000000)]
fn quantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(1000, false));
data.append(FixedTrait::new_unscaled(254, true));
data.append(FixedTrait::new_unscaled(1000, true));
let x = TensorTrait::new(shape.span(), data.span());
// YSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(2, false));
let y_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(1, false));
let y_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i8> = x.quantize_linear(@y_scale, @y_zero_point);
assert((*y.data[0]).into() == 1, '*result[0] == 1');
assert((*y.data[1]).into() == 2, '*result[1] == 2');
assert((*y.data[2]).into() == 2, '*result[2] == 2');
assert((*y.data[3]).into() == 127, '*result[3] == 127');
assert((*y.data[4]).into() == -126, '*result[4] == -126');
assert((*y.data[5]).into() == -127, '*result[5] == -127');
}
#[test]
#[available_gas(20000000)]
fn per_axis() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(162, true));
data.append(FixedTrait::new_unscaled(10, false));
data.append(FixedTrait::new_unscaled(100, true));
data.append(FixedTrait::new_unscaled(232, false));
data.append(FixedTrait::new_unscaled(20, true));
data.append(FixedTrait::new_unscaled(50, true));
data.append(FixedTrait::new_unscaled(76, true));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(252, false));
data.append(FixedTrait::new_unscaled(32, false));
data.append(FixedTrait::new_unscaled(44, true));
data.append(FixedTrait::new_unscaled(245, false));
data.append(FixedTrait::new_unscaled(485, true));
data.append(FixedTrait::new_unscaled(960, true));
data.append(FixedTrait::new_unscaled(270, true));
data.append(FixedTrait::new_unscaled(375, true));
data.append(FixedTrait::new_unscaled(470, true));
let x = TensorTrait::new(shape.span(), data.span());
// YSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(4, false));
data.append(FixedTrait::new_unscaled(5, false));
let y_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<FP16x16>::new();
data.append(FixedTrait::new_unscaled(84, false));
data.append(FixedTrait::new_unscaled(24, false));
data.append(FixedTrait::new_unscaled(196, false));
let y_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i8> = x.quantize_linear(@y_scale, @y_zero_point);
assert((*y.data[0]).into() == 3, '*result[0] == 3');
assert((*y.data[1]).into() == 89, '*result[1] == 89');
assert((*y.data[2]).into() == 34, '*result[2] == 34');
assert((*y.data[3]).into() == 127, '*result[3] == 127');
assert((*y.data[4]).into() == 74, '*result[4] == 74');
assert((*y.data[5]).into() == 59, '*result[5] == 59');
assert((*y.data[6]).into() == 5, '*result[6] == 5');
assert((*y.data[7]).into() == 24, '*result[7] == 24');
assert((*y.data[8]).into() == 24, '*result[8] == 24');
assert((*y.data[9]).into() == 87, '*result[9] == 87');
assert((*y.data[10]).into() == 32, '*result[10] == 32');
assert((*y.data[11]).into() == 13, '*result[11] == 13');
assert((*y.data[12]).into() == 127, '*result[12] == 127');
assert((*y.data[13]).into() == 99, '*result[13] == 99');
assert((*y.data[14]).into() == 4, '*result[14] == 4');
assert((*y.data[15]).into() == 127, '*result[15] == 127');
assert((*y.data[16]).into() == 121, '*result[16] == 121');
assert((*y.data[17]).into() == 102, '*result[17] == 102');
}
}
| https://github.com/gizatechxyz/orion |
tests/performance/quantize_linear_test/quantize_linear_i32_test.cairo | use core::debug::{PrintTrait};
use core::array::ArrayTrait;
use core::array::SpanTrait;
use core::traits::Into;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000)]
fn quantize_linear() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::<i32>::new();
data.append(0);
data.append(2);
data.append(3);
data.append(1000);
data.append(-254);
data.append(-1000);
let x = TensorTrait::new(shape.span(), data.span());
// YSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(2);
let y_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(1);
let y_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i8> = x.quantize_linear(@y_scale, @y_zero_point);
assert((*y.data[0]).into() == 1, '*result[0] == 1');
assert((*y.data[1]).into() == 2, '*result[1] == 2');
assert((*y.data[2]).into() == 2, '*result[2] == 2');
assert((*y.data[3]).into() == 127, '*result[3] == 127');
assert((*y.data[4]).into() == -126, '*result[4] == -126');
assert((*y.data[5]).into() == -127, '*result[5] == -127');
}
#[test]
#[available_gas(20000000)]
fn per_axis() {
// X
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::<i32>::new();
data.append(-162);
data.append(10);
data.append(-100);
data.append(232);
data.append(-20);
data.append(-50);
data.append(-76);
data.append(0);
data.append(0);
data.append(252);
data.append(32);
data.append(-44);
data.append(245);
data.append(-485);
data.append(-960);
data.append(-270);
data.append(-375);
data.append(-470);
let x = TensorTrait::new(shape.span(), data.span());
// YSCALE
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(2);
data.append(4);
data.append(5);
let y_scale = TensorTrait::new(shape.span(), data.span());
// ZEROPOINT
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(3);
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::<i32>::new();
data.append(84);
data.append(24);
data.append(196);
let y_zero_point = TensorTrait::new(shape.span(), data.span());
let y: Tensor<i8> = x.quantize_linear(@y_scale, @y_zero_point);
assert((*y.data[0]).into() == 3, '*result[0] == 3');
assert((*y.data[1]).into() == 89, '*result[1] == 89');
assert((*y.data[2]).into() == 34, '*result[2] == 34');
assert((*y.data[3]).into() == 127, '*result[3] == 127');
assert((*y.data[4]).into() == 74, '*result[4] == 74');
assert((*y.data[5]).into() == 59, '*result[5] == 59');
assert((*y.data[6]).into() == 5, '*result[6] == 5');
assert((*y.data[7]).into() == 24, '*result[7] == 24');
assert((*y.data[8]).into() == 24, '*result[8] == 24');
assert((*y.data[9]).into() == 87, '*result[9] == 87');
assert((*y.data[10]).into() == 32, '*result[10] == 32');
assert((*y.data[11]).into() == 13, '*result[11] == 13');
assert((*y.data[12]).into() == 127, '*result[12] == 127');
assert((*y.data[13]).into() == 99, '*result[13] == 99');
assert((*y.data[14]).into() == 4, '*result[14] == 4');
assert((*y.data[15]).into() == 127, '*result[15] == 127');
assert((*y.data[16]).into() == 121, '*result[16] == 121');
assert((*y.data[17]).into() == 102, '*result[17] == 102');
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core.cairo | mod at;
mod flatten;
mod max;
mod min;
mod stride;
mod onehot;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/at.cairo | mod at_u32_test;
mod at_i32_test;
mod at_fp_test;
mod at_bool_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/at/at_bool_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::core::{TensorTrait};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let mut sizes = ArrayTrait::new();
sizes.append(3);
let mut data = ArrayTrait::new();
data.append(false);
data.append(true);
data.append(false);
let tensor = TensorTrait::<bool>::new(sizes.span(), data.span());
let mut indices = ArrayTrait::new();
indices.append(1);
let result = tensor.at(indices.span());
assert(result == true, 'result[2] = true');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use orion::operators::tensor::{BoolTensor};
use orion::operators::tensor::core::{TensorTrait};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(true);
let tensor = TensorTrait::<bool>::new(sizes.span(), data.span());
let mut indices = ArrayTrait::new();
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == true, 'result[4] = true');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use orion::operators::tensor::{BoolTensor};
use orion::operators::tensor::core::{TensorTrait};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(false);
data.append(false);
let tensor = TensorTrait::<bool>::new(sizes.span(), data.span());
let mut indices = ArrayTrait::new();
indices.append(0);
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == true, 'result[3] = true');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/at/at_fp_test.cairo | mod at_fp8x23_test;
mod at_fp16x16_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/at/at_fp_test/at_fp16x16_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::core::FixedTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{
FP16x16Impl, FP16x16PartialEq
};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = fp_tensor_1x3_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
let result = tensor.at(indices.span());
assert(result == FixedTrait::new_unscaled(1, false), 'result[2] = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::core::FixedTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{
FP16x16Impl, FP16x16PartialEq
};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = fp_tensor_2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == FixedTrait::new_unscaled(3, false), 'result[4] = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::core::FixedTrait;
use orion::numbers::fixed_point::implementations::fp16x16::core::{
FP16x16Impl, FP16x16PartialEq
};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = fp_tensor_2x2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(0);
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == FixedTrait::new_unscaled(3, false), 'result[3] = 3');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/at/at_fp_test/at_fp8x23_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::core::FixedTrait;
use orion::numbers::fixed_point::implementations::fp8x23::core::{FP8x23Impl, FP8x23PartialEq};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = fp_tensor_1x3_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
let result = tensor.at(indices.span());
assert(result == FixedTrait::new_unscaled(1, false), 'result[2] = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::core::FixedTrait;
use orion::numbers::fixed_point::implementations::fp8x23::core::{FP8x23Impl, FP8x23PartialEq};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = fp_tensor_2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == FixedTrait::new_unscaled(3, false), 'result[4] = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::core::FixedTrait;
use orion::numbers::fixed_point::implementations::fp8x23::core::{FP8x23Impl, FP8x23PartialEq};
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = fp_tensor_2x2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(0);
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == FixedTrait::new_unscaled(3, false), 'result[3] = 3');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/at/at_i32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = i32_tensor_1x3_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
let result = tensor.at(indices.span());
assert(result == 1, 'result[2] = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = i32_tensor_2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == 3, 'result[4] = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = i32_tensor_2x2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(0);
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == 3, 'result[3] = 3');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/at/at_u32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::ArrayTrait;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = u32_tensor_1x3_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
let result = tensor.at(indices.span());
assert(result == 1, 'result[2] = 1');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::ArrayTrait;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = u32_tensor_2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == 3, 'result[4] = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::ArrayTrait;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_at() {
let tensor = u32_tensor_2x2x2_helper();
let mut indices = ArrayTrait::new();
indices.append(0);
indices.append(1);
indices.append(1);
let result = tensor.at(indices.span());
assert(result == 3, 'result[3] = 3');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/flatten.cairo | mod flatten_i32_test;
mod flatten_u32_test;
mod flatten_fp_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/flatten/flatten_fp_test.cairo | mod flatten_fp8x23_test;
mod flatten_fp16x16_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/flatten/flatten_fp_test/flatten_fp16x16_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::traits::Into;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_1x3_helper;
use orion::operators::tensor::core::TensorTrait;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 3, 'result[1] = 3');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::traits::Into;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2_helper;
use orion::operators::tensor::core::TensorTrait;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::traits::Into;
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2x2_helper;
use orion::operators::tensor::core::TensorTrait;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 8, 'result[1] = 8');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_2() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.flatten(2);
assert((*result.shape[0]).into() == 4, 'result[0] = 4');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/flatten/flatten_fp_test/flatten_fp8x23_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::traits::Into;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_1x3_helper;
use orion::operators::tensor::core::TensorTrait;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 3, 'result[1] = 3');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::traits::Into;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2_helper;
use orion::operators::tensor::core::TensorTrait;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::traits::Into;
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2x2_helper;
use orion::operators::tensor::core::TensorTrait;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 8, 'result[1] = 8');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_2() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.flatten(2);
assert((*result.shape[0]).into() == 4, 'result[0] = 4');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/flatten/flatten_i32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_1x3_helper;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = i32_tensor_1x3_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 3, 'result[1] = 3');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_2x2_helper;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = i32_tensor_2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = i32_tensor_2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::i32::i32_tensor_2x2x2_helper;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 8, 'result[1] = 8');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_2() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.flatten(2);
assert((*result.shape[0]).into() == 4, 'result[0] = 4');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/flatten/flatten_u32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_1x3_helper;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = u32_tensor_1x3_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 3, 'result[1] = 3');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_2x2_helper;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = u32_tensor_2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = u32_tensor_2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::{TensorTrait};
use orion::test_helper::tensor::u32::u32_tensor_2x2x2_helper;
#[test]
#[available_gas(200000)]
fn axis_0() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.flatten(0);
assert((*result.shape[0]).into() == 1, 'result[0] = 1');
assert((*result.shape[1]).into() == 8, 'result[1] = 8');
}
#[test]
#[available_gas(200000)]
fn axis_1() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.flatten(1);
assert((*result.shape[0]).into() == 2, 'result[0] = 2');
assert((*result.shape[1]).into() == 4, 'result[1] = 4');
}
#[test]
#[available_gas(200000)]
fn axis_2() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.flatten(2);
assert((*result.shape[0]).into() == 4, 'result[0] = 4');
assert((*result.shape[1]).into() == 2, 'result[1] = 2');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/max.cairo | mod max_u32_test;
mod max_i32_test;
mod max_fp_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/max/max_fp_test.cairo | mod max_fp8x23_test;
mod max_fp16x16_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/max/max_fp_test/max_fp16x16_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP16x16>::new_unscaled(2, false).mag, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP16x16>::new_unscaled(3, false).mag, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP16x16>::new_unscaled(7, false).mag, 'tensor.max = 7');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/max/max_fp_test/max_fp8x23_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP8x23>::new_unscaled(2, false).mag, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP8x23>::new_unscaled(3, false).mag, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.max_in_tensor().mag;
assert(result == FixedTrait::<FP8x23>::new_unscaled(7, false).mag, 'tensor.max = 7');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/max/max_i32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = i32_tensor_1x3_helper();
let result = tensor.max_in_tensor();
assert(result == 2, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = i32_tensor_2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 3, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 7, 'tensor.max = 7');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/max/max_u32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = u32_tensor_1x3_helper();
let result = tensor.max_in_tensor();
assert(result == 2, 'tensor.max = 2');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = u32_tensor_2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 3, 'tensor.max = 3');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_max() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.max_in_tensor();
assert(result == 7, 'tensor.max = 7');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/min.cairo | mod min_u32_test;
mod min_i32_test;
mod min_fp_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/min/min_fp_test.cairo | mod min_fp8x23_test;
mod min_fp16x16_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/min/min_fp_test/min_fp16x16_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp16x16::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/min/min_fp_test/min_fp8x23_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_1x3_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_1x3_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::fp_tensor_2x2x2_helper;
use orion::numbers::fixed_point::implementations::fp8x23::core::FP8x23Impl;
use orion::numbers::fixed_point::core::{FixedTrait};
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = fp_tensor_2x2x2_helper();
let result = tensor.min_in_tensor().mag;
assert(result == 0, 'tensor.min = 0');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/min/min_i32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = i32_tensor_1x3_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = i32_tensor_2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::I32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::i32::i32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = i32_tensor_2x2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/min/min_u32_test.cairo | // ===== 1D ===== //
#[cfg(test)]
mod tensor_1D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_1x3_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = u32_tensor_1x3_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 2D ===== //
#[cfg(test)]
mod tensor_2D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = u32_tensor_2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
// ===== 3D ===== //
#[cfg(test)]
mod tensor_3D {
use orion::operators::tensor::U32Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::u32::u32_tensor_2x2x2_helper;
#[test]
#[available_gas(2000000)]
fn tensor_min() {
let tensor = u32_tensor_2x2x2_helper();
let result = tensor.min_in_tensor();
assert(result == 0, 'tensor.min = 0');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/onehot.cairo | mod onehot_fp_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/onehot/onehot_fp_test.cairo | mod onehot_fp8x23_test;
mod onehot_fp16x16_test;
| https://github.com/gizatechxyz/orion |
tests/tensor_core/onehot/onehot_fp_test/onehot_fp16x16_test.cairo | use core::serde::Serde;
use core::option::OptionTrait;
use core::clone::Clone;
// ===== 1D ===== //
use orion::numbers::fixed_point::core::FixedTrait;
#[cfg(test)]
mod tensor_1D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp16x16::core::{FP16x16, FP16x16PartialEq};
use orion::operators::tensor::implementations::tensor_fp16x16::FP16x16Tensor;
use orion::test_helper::tensor::fixed_point::fp16x16::{
fp_tensor_1x3_helper, fp_tensor_2x2_helper, fp_tensor_3x2x2_neg_helper,
fp_tensor_1x3_neg_helper, fp_tensor_2x2x2_helper
};
use orion::operators::tensor::core::TensorTrait;
use core::debug::PrintTrait;
use core::clone::Clone;
use core::option::OptionTrait;
use core::serde::Serde;
// use orion::numbers::fixed_point::implementations::fp16x16::core::FP16x16Impl;
// use orion::operators::tensor::implementations::impl_tensor_fp::Tensor_fp;
use orion::operators::tensor::core::{Tensor};
fn fp_tensor_3x2x2_new() -> Tensor<FP16x16> {
let mut sizes = ArrayTrait::new();
sizes.append(3);
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
let tensor = TensorTrait::<FP16x16>::new(sizes.span(), data.span());
return tensor;
}
fn fp_tensor_2x2_pos_neg_new() -> Tensor<FP16x16> {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, true));
data.append(FixedTrait::new_unscaled(1, true));
let tensor = TensorTrait::<FP16x16>::new(sizes.span(), data.span());
return tensor;
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_last_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_neg_last_axis() {
let tensor = fp_tensor_1x3_neg_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_2x2_post_neg_last_axis() {
let tensor = fp_tensor_2x2_pos_neg_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 1');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 0');
assert((*result.data[11]) == FixedTrait::new_unscaled(1, false), 'result[11] = 0');
}
#[test]
#[should_panic]
#[available_gas(20000000)]
fn tensor_onehot_tensor_1x3_fail() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_Zero_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_axis_one() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_2x2_helper_last_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 4, 'shape[0] = 4');
}
#[test]
#[should_panic]
#[available_gas(20000000)]
fn tensor_onehot_tensor_2x2_fail() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_2x2_helper_first_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_2x2_helper_second_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 4, 'shape[0] = 4');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_last_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
// let axis: Option<usize> = Option::Some(3);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_unscaled(1, false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 2, 'shape[2] = 2');
assert((*result.shape.at(3)) == 4, 'shape[0] = 4');
}
#[test]
#[should_panic]
#[available_gas(20000000)]
fn tensor_onehot_tensor_3x2x2_fail() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(4);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_first_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(2);
values.append(5);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(5, false), 'result[0] = 5');
assert((*result.data[1]) == FixedTrait::new_unscaled(2, false), 'result[1] = 2');
assert((*result.data[2]) == FixedTrait::new_unscaled(2, false), 'result[2] = 2');
assert((*result.data[3]) == FixedTrait::new_unscaled(2, false), 'result[3] = 2');
assert((*result.data[4]) == FixedTrait::new_unscaled(5, false), 'result[4] = 5');
assert((*result.data[5]) == FixedTrait::new_unscaled(2, false), 'result[5] = 2');
assert((*result.data[6]) == FixedTrait::new_unscaled(2, false), 'result[6] = 2');
assert((*result.data[7]) == FixedTrait::new_unscaled(2, false), 'result[7] = 2');
assert((*result.data[8]) == FixedTrait::new_unscaled(5, false), 'result[8] = 5');
assert((*result.data[9]) == FixedTrait::new_unscaled(2, false), 'result[9] = 2');
assert((*result.data[10]) == FixedTrait::new_unscaled(2, false), 'result[10] = 2');
assert((*result.data[11]) == FixedTrait::new_unscaled(2, false), 'result[11] = 2');
assert((*result.data[12]) == FixedTrait::new_unscaled(2, false), 'result[12] = 2');
assert((*result.data[13]) == FixedTrait::new_unscaled(5, false), 'result[13] = 5');
assert((*result.data[14]) == FixedTrait::new_unscaled(2, false), 'result[14] = 2');
assert((*result.data[17]) == FixedTrait::new_unscaled(5, false), 'result[17] = 5');
assert((*result.data[21]) == FixedTrait::new_unscaled(5, false), 'result[21] = 5');
assert((*result.data[26]) == FixedTrait::new_unscaled(5, false), 'result[26] = 5');
assert((*result.data[30]) == FixedTrait::new_unscaled(5, false), 'result[30] = 5');
assert((*result.data[34]) == FixedTrait::new_unscaled(5, false), 'result[34] = 5');
assert((*result.data[39]) == FixedTrait::new_unscaled(5, false), 'result[39] = 5');
assert((*result.data[43]) == FixedTrait::new_unscaled(5, false), 'result[43] = 5');
assert((*result.data[46]) == FixedTrait::new_unscaled(2, false), 'result[46] = 2');
assert((*result.data[47]) == FixedTrait::new_unscaled(5, false), 'result[47] = 5');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 3, 'shape[1] = 3');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_second_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_unscaled(1, false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 4, 'shape[1] = 4');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_third_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(2);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[19]) == FixedTrait::new_unscaled(1, false), 'result[19] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(0, false), 'result[21] = 0');
assert((*result.data[26]) == FixedTrait::new_unscaled(0, false), 'result[26] = 0');
assert((*result.data[28]) == FixedTrait::new_unscaled(1, false), 'result[28] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[35]) == FixedTrait::new_unscaled(1, false), 'result[35] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(0, false), 'result[37] = 0');
assert((*result.data[44]) == FixedTrait::new_unscaled(1, false), 'result[44] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 4, 'shape[2] = 4');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
}
| https://github.com/gizatechxyz/orion |
tests/tensor_core/onehot/onehot_fp_test/onehot_fp8x23_test.cairo | use core::serde::Serde;
use core::option::OptionTrait;
use core::clone::Clone;
// ===== 1D ===== //
use orion::numbers::fixed_point::core::FixedTrait;
#[cfg(test)]
mod tensor_1D {
use core::array::{ArrayTrait, SpanTrait};
use core::traits::Into;
use orion::numbers::fixed_point::core::{FixedTrait};
use orion::numbers::fixed_point::implementations::fp8x23::core::{FP8x23, FP8x23PartialEq};
use orion::operators::tensor::implementations::tensor_fp8x23::FP8x23Tensor;
use orion::operators::tensor::core::TensorTrait;
use orion::test_helper::tensor::fixed_point::fp8x23::{
fp_tensor_1x3_helper, fp_tensor_2x2_helper, fp_tensor_3x2x2_neg_helper,
fp_tensor_1x3_neg_helper, fp_tensor_2x2x2_helper
};
use core::debug::PrintTrait;
use core::clone::Clone;
use core::option::OptionTrait;
use core::serde::Serde;
use orion::operators::tensor::core::{Tensor};
fn fp_tensor_3x2x2_new() -> Tensor<FP8x23> {
let mut sizes = ArrayTrait::new();
sizes.append(3);
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, false));
data.append(FixedTrait::new_unscaled(3, false));
let tensor = TensorTrait::<FP8x23>::new(sizes.span(), data.span());
return tensor;
}
fn fp_tensor_2x2_pos_neg_new() -> Tensor<FP8x23> {
let mut sizes = ArrayTrait::new();
sizes.append(2);
sizes.append(2);
let mut data = ArrayTrait::new();
data.append(FixedTrait::new_unscaled(0, false));
data.append(FixedTrait::new_unscaled(1, false));
data.append(FixedTrait::new_unscaled(2, true));
data.append(FixedTrait::new_unscaled(1, true));
let tensor = TensorTrait::<FP8x23>::new(sizes.span(), data.span());
return tensor;
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_last_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_neg_last_axis() {
let tensor = fp_tensor_1x3_neg_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_2x2_post_neg_last_axis() {
let tensor = fp_tensor_2x2_pos_neg_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(1, false), 'result[7] = 1');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 0');
assert((*result.data[11]) == FixedTrait::new_unscaled(1, false), 'result[11] = 0');
}
#[test]
#[should_panic]
#[available_gas(20000000)]
fn tensor_onehot_tensor_1x3_fail() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_Zero_axis() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn tensor_onehot_1x3_axis_one() {
let tensor = fp_tensor_1x3_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 3;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(1, false), 'result[4] = 1');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(1, false), 'result[8] = 1');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_2x2_helper_last_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 4, 'shape[0] = 4');
}
#[test]
#[should_panic]
#[available_gas(20000000)]
fn tensor_onehot_tensor_2x2_fail() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(3);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_2x2_helper_first_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 2, 'shape[0] = 2');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_2x2_helper_second_axis() {
let tensor = fp_tensor_2x2_helper();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(0, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.shape.at(0)) == 2, 'shape[0] = 2');
assert((*result.shape.at(1)) == 4, 'shape[0] = 4');
assert((*result.shape.at(2)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_last_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::None(());
// let axis: Option<usize> = Option::Some(3);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_unscaled(1, false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 2, 'shape[2] = 2');
assert((*result.shape.at(3)) == 4, 'shape[0] = 4');
}
#[test]
#[should_panic]
#[available_gas(20000000)]
fn tensor_onehot_tensor_3x2x2_fail() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(4);
let _result = tensor.onehot(depth: depth, axis: axis, values: values.span());
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_first_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(2);
values.append(5);
let depth = 4;
let axis: Option<usize> = Option::Some(0);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(5, false), 'result[0] = 5');
assert((*result.data[1]) == FixedTrait::new_unscaled(2, false), 'result[1] = 2');
assert((*result.data[2]) == FixedTrait::new_unscaled(2, false), 'result[2] = 2');
assert((*result.data[3]) == FixedTrait::new_unscaled(2, false), 'result[3] = 2');
assert((*result.data[4]) == FixedTrait::new_unscaled(5, false), 'result[4] = 5');
assert((*result.data[5]) == FixedTrait::new_unscaled(2, false), 'result[5] = 2');
assert((*result.data[6]) == FixedTrait::new_unscaled(2, false), 'result[6] = 2');
assert((*result.data[7]) == FixedTrait::new_unscaled(2, false), 'result[7] = 2');
assert((*result.data[8]) == FixedTrait::new_unscaled(5, false), 'result[8] = 5');
assert((*result.data[9]) == FixedTrait::new_unscaled(2, false), 'result[9] = 2');
assert((*result.data[10]) == FixedTrait::new_unscaled(2, false), 'result[10] = 2');
assert((*result.data[11]) == FixedTrait::new_unscaled(2, false), 'result[11] = 2');
assert((*result.data[12]) == FixedTrait::new_unscaled(2, false), 'result[12] = 2');
assert((*result.data[13]) == FixedTrait::new_unscaled(5, false), 'result[13] = 5');
assert((*result.data[14]) == FixedTrait::new_unscaled(2, false), 'result[14] = 2');
assert((*result.data[17]) == FixedTrait::new_unscaled(5, false), 'result[17] = 5');
assert((*result.data[21]) == FixedTrait::new_unscaled(5, false), 'result[21] = 5');
assert((*result.data[26]) == FixedTrait::new_unscaled(5, false), 'result[26] = 5');
assert((*result.data[30]) == FixedTrait::new_unscaled(5, false), 'result[30] = 5');
assert((*result.data[34]) == FixedTrait::new_unscaled(5, false), 'result[34] = 5');
assert((*result.data[39]) == FixedTrait::new_unscaled(5, false), 'result[39] = 5');
assert((*result.data[43]) == FixedTrait::new_unscaled(5, false), 'result[43] = 5');
assert((*result.data[46]) == FixedTrait::new_unscaled(2, false), 'result[46] = 2');
assert((*result.data[47]) == FixedTrait::new_unscaled(5, false), 'result[47] = 5');
assert((*result.shape.at(0)) == 4, 'shape[0] = 4');
assert((*result.shape.at(1)) == 3, 'shape[1] = 3');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_second_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(1);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(0, false), 'result[3] = 0');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(1, false), 'result[5] = 1');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[7]) == FixedTrait::new_unscaled(0, false), 'result[7] = 0');
assert((*result.data[8]) == FixedTrait::new_unscaled(0, false), 'result[8] = 0');
assert((*result.data[9]) == FixedTrait::new_unscaled(0, false), 'result[9] = 0');
assert((*result.data[10]) == FixedTrait::new_unscaled(1, false), 'result[10] = 1');
assert((*result.data[11]) == FixedTrait::new_unscaled(0, false), 'result[11] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(0, false), 'result[12] = 0');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(1, false), 'result[21] = 1');
assert((*result.data[26]) == FixedTrait::new_unscaled(1, false), 'result[26] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(1, false), 'result[37] = 1');
assert((*result.data[42]) == FixedTrait::new_unscaled(1, false), 'result[42] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 4, 'shape[1] = 4');
assert((*result.shape.at(2)) == 2, 'shape[2] = 3');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
#[test]
#[available_gas(20000000)]
fn fp_tensor_onehot_3x2x2_new_third_axis() {
let tensor = fp_tensor_3x2x2_new();
let mut values = ArrayTrait::new();
values.append(0);
values.append(1);
let depth = 4;
let axis: Option<usize> = Option::Some(2);
let result = tensor.onehot(depth: depth, axis: axis, values: values.span());
assert((*result.data[0]) == FixedTrait::new_unscaled(1, false), 'result[0] = 1');
assert((*result.data[1]) == FixedTrait::new_unscaled(0, false), 'result[1] = 0');
assert((*result.data[2]) == FixedTrait::new_unscaled(0, false), 'result[2] = 0');
assert((*result.data[3]) == FixedTrait::new_unscaled(1, false), 'result[3] = 1');
assert((*result.data[4]) == FixedTrait::new_unscaled(0, false), 'result[4] = 0');
assert((*result.data[5]) == FixedTrait::new_unscaled(0, false), 'result[5] = 0');
assert((*result.data[6]) == FixedTrait::new_unscaled(0, false), 'result[6] = 0');
assert((*result.data[12]) == FixedTrait::new_unscaled(1, false), 'result[12] = 1');
assert((*result.data[13]) == FixedTrait::new_unscaled(0, false), 'result[13] = 0');
assert((*result.data[14]) == FixedTrait::new_unscaled(0, false), 'result[14] = 0');
assert((*result.data[15]) == FixedTrait::new_unscaled(1, false), 'result[15] = 1');
assert((*result.data[16]) == FixedTrait::new_unscaled(1, false), 'result[16] = 1');
assert((*result.data[19]) == FixedTrait::new_unscaled(1, false), 'result[19] = 1');
assert((*result.data[21]) == FixedTrait::new_unscaled(0, false), 'result[21] = 0');
assert((*result.data[26]) == FixedTrait::new_unscaled(0, false), 'result[26] = 0');
assert((*result.data[28]) == FixedTrait::new_unscaled(1, false), 'result[28] = 1');
assert((*result.data[31]) == FixedTrait::new_unscaled(1, false), 'result[31] = 1');
assert((*result.data[32]) == FixedTrait::new_unscaled(1, false), 'result[32] = 1');
assert((*result.data[35]) == FixedTrait::new_unscaled(1, false), 'result[35] = 1');
assert((*result.data[37]) == FixedTrait::new_unscaled(0, false), 'result[37] = 0');
assert((*result.data[44]) == FixedTrait::new_unscaled(1, false), 'result[44] = 1');
assert((*result.data[46]) == FixedTrait::new_unscaled(0, false), 'result[46] = 0');
assert((*result.data[47]) == FixedTrait::new_unscaled(1, false), 'result[47] = 1');
assert((*result.shape.at(0)) == 3, 'shape[0] = 3');
assert((*result.shape.at(1)) == 2, 'shape[1] = 2');
assert((*result.shape.at(2)) == 4, 'shape[2] = 4');
assert((*result.shape.at(3)) == 2, 'shape[0] = 2');
}
}
| https://github.com/gizatechxyz/orion |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.