file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
tests/nodes/grid_sample_nearest_aligncorner/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(4);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 32768, sign: true });
data.append(FP16x16 { mag: 32768, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 32768, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_nearest_aligncorner/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(2);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_border.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::nn::FP16x16NN;
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::nn::functional::grid_sample::PADDING_MODE;
#[test]
#[available_gas(2000000000)]
fn test_grid_sample_padding_border() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = NNTrait::grid_sample(
@input_0, @input_1, Option::None, Option::None, Option::Some(PADDING_MODE::BORDER)
);
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_border/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_border/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(4);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 655360, sign: true });
data.append(FP16x16 { mag: 655360, sign: true });
data.append(FP16x16 { mag: 327680, sign: true });
data.append(FP16x16 { mag: 327680, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_border/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(2);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 111411, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 111411, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_reflection.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::nn::FP16x16NN;
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::nn::functional::grid_sample::PADDING_MODE;
#[test]
#[available_gas(2000000000)]
fn test_grid_sample_padding_reflection() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = NNTrait::grid_sample(
@input_0, @input_1, Option::None, Option::None, Option::Some(PADDING_MODE::REFLECTION)
);
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_reflection/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_reflection/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(4);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 655360, sign: true });
data.append(FP16x16 { mag: 655360, sign: true });
data.append(FP16x16 { mag: 327680, sign: true });
data.append(FP16x16 { mag: 327680, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_reflection/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(2);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 163840, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 111411, sign: false });
data.append(FP16x16 { mag: 163840, sign: false });
data.append(FP16x16 { mag: 163840, sign: false });
data.append(FP16x16 { mag: 111411, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 163840, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_zeros.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::nn::FP16x16NN;
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::nn::functional::grid_sample::PADDING_MODE;
#[test]
#[available_gas(2000000000)]
fn test_grid_sample_padding_zeros() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z_0 = output_0::output_0();
let y_0 = NNTrait::grid_sample(@input_0, @input_1, Option::None, Option::None, Option::None);
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_zeros/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(3);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_zeros/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
shape.append(4);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 655360, sign: true });
data.append(FP16x16 { mag: 655360, sign: true });
data.append(FP16x16 { mag: 327680, sign: true });
data.append(FP16x16 { mag: 327680, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 13107, sign: true });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
data.append(FP16x16 { mag: 655360, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/grid_sample_padding_zeros/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
shape.append(2);
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 111411, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 111411, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hamming_window_fp16x16.cairo | mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::{FixedTrait, FP16x16};
#[test]
#[available_gas(2000000000)]
fn test_hamming_window_fp16x16() {
let z_0 = output_0::output_0();
let y_0 = TensorTrait::hamming_window(FP16x16 { mag: 655360, sign: false }, Option::Some(0));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hamming_window_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(10);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 5696, sign: false });
data.append(FP16x16 { mag: 12688, sign: false });
data.append(FP16x16 { mag: 30400, sign: false });
data.append(FP16x16 { mag: 50560, sign: false });
data.append(FP16x16 { mag: 63712, sign: false });
data.append(FP16x16 { mag: 63744, sign: false });
data.append(FP16x16 { mag: 50624, sign: false });
data.append(FP16x16 { mag: 30432, sign: false });
data.append(FP16x16 { mag: 12752, sign: false });
data.append(FP16x16 { mag: 5696, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hamming_window_fp8x23.cairo | mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::numbers::{FixedTrait, FP8x23};
#[test]
#[available_gas(2000000000)]
fn test_hamming_window_fp8x23() {
let z_0 = output_0::output_0();
let y_0 = TensorTrait::hamming_window(FP8x23 { mag: 33554432, sign: false }, Option::Some(0));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hamming_window_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 729444, sign: false });
data.append(FP8x23 { mag: 6473817, sign: false });
data.append(FP8x23 { mag: 6473817, sign: false });
data.append(FP8x23 { mag: 729444, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hann_window_fp16x16.cairo | mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::numbers::{FixedTrait, FP16x16};
#[test]
#[available_gas(2000000000)]
fn test_hann_window_fp16x16() {
let z_0 = output_0::output_0();
let y_0 = TensorTrait::hann_window(FP16x16 { mag: 655360, sign: false }, Option::Some(0));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hann_window_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(10);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 7656, sign: false });
data.append(FP16x16 { mag: 27056, sign: false });
data.append(FP16x16 { mag: 49120, sign: false });
data.append(FP16x16 { mag: 63552, sign: false });
data.append(FP16x16 { mag: 63552, sign: false });
data.append(FP16x16 { mag: 49184, sign: false });
data.append(FP16x16 { mag: 27104, sign: false });
data.append(FP16x16 { mag: 7732, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hann_window_fp8x23.cairo | mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::numbers::{FixedTrait, FP8x23};
#[test]
#[available_gas(2000000000)]
fn test_hann_window_fp8x23() {
let z_0 = output_0::output_0();
let y_0 = TensorTrait::hann_window(FP8x23 { mag: 33554432, sign: false }, Option::Some(0));
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hann_window_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 6291455, sign: false });
data.append(FP8x23 { mag: 6291456, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hard_sigmoid_fp16x16.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::nn::FP16x16NN;
#[test]
#[available_gas(2000000000)]
fn test_hard_sigmoid_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::hard_sigmoid(
@input_0, @FixedTrait::new(13107, false), @FixedTrait::new(32768, false)
);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hard_sigmoid_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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 163137, sign: false });
data.append(FP16x16 { mag: 109300, sign: true });
data.append(FP16x16 { mag: 28237, sign: false });
data.append(FP16x16 { mag: 20376, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hard_sigmoid_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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65395, sign: false });
data.append(FP16x16 { mag: 10907, sign: false });
data.append(FP16x16 { mag: 38415, sign: false });
data.append(FP16x16 { mag: 28692, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hard_sigmoid_fp8x23.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::nn::FP8x23NN;
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
#[test]
#[available_gas(2000000000)]
fn test_hard_sigmoid_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::hard_sigmoid(
@input_0, @FixedTrait::new(1677721, false), @FixedTrait::new(4194304, false)
);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hard_sigmoid_fp8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1488696, sign: true });
data.append(FP8x23 { mag: 14193978, sign: true });
data.append(FP8x23 { mag: 23668532, sign: true });
data.append(FP8x23 { mag: 19142362, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/hard_sigmoid_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 3896564, sign: false });
data.append(FP8x23 { mag: 1355508, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8022776, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_fP16x16.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_fP16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 4, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_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(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 3, sign: false });
data.append(FP16x16 { mag: 4, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_fP8x23.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::FP8x23TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_fP8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_fP8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1, sign: false });
data.append(FP8x23 { mag: 2, sign: false });
data.append(FP8x23 { mag: 3, sign: false });
data.append(FP8x23 { mag: 4, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_fP8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1, sign: false });
data.append(FP8x23 { mag: 2, sign: false });
data.append(FP8x23 { mag: 3, sign: false });
data.append(FP8x23 { mag: 4, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_i32.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::I32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorSub};
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_i32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorSub};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_i32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorSub};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_i8.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::{I8Tensor, I8TensorSub};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_i8/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorSub};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_i8/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorSub};
fn output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_u32.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{U32Tensor, U32TensorSub};
use core::array::{ArrayTrait, SpanTrait};
#[test]
#[available_gas(2000000000)]
fn test_identity_u32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.identity();
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_u32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorSub};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/identity_u32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorSub};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(1);
data.append(2);
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_fp16x16.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_fp16x16/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 78643, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FP16x16 { mag: 183500, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FixedTrait::NEG_INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_fp8x23.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_fp8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 10066329, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FP8x23 { mag: 23488102, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FixedTrait::NEG_INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_i32.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_i32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::{NumberTrait};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_i32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_i8.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_inf_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_i8/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::{NumberTrait};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_i8/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_u32.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::U32TensorPartialEq;
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_inf_u32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::None, Option::None);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_u32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorAdd};
use orion::numbers::NumberTrait;
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF());
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_inf_u32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_nan_fp16x16.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
use orion::operators::tensor::BoolTensor;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_nan_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_nan(@input_0);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_nan_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(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 78643, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FixedTrait::NaN());
data.append(FP16x16 { mag: 183500, sign: false });
data.append(FixedTrait::NaN());
data.append(FixedTrait::NaN());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_nan_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_nan_fp8x23.cairo | mod input_0;
mod output_0;
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_nan_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_nan(@input_0);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_nan_fp8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 10066329, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FixedTrait::NaN());
data.append(FP8x23 { mag: 23488102, sign: false });
data.append(FixedTrait::NaN());
data.append(FixedTrait::NaN());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_nan_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(true);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_fp16x16.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_fp16x16/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FP16x16 { mag: 2, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FixedTrait::POS_INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_fp8x23.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_fp8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FixedTrait::POS_INF());
data.append(FP8x23 { mag: 2, sign: false });
data.append(FixedTrait::NEG_INF());
data.append(FixedTrait::POS_INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_i32.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_i32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::{NumberTrait};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_i32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_i8.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_neg_inf_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(1), Option::Some(0));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_i8/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::{NumberTrait};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_neg_inf_i8/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(false);
data.append(false);
data.append(true);
data.append(false);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_fp16x16.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::FP16x16TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_fp16x16/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 1, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 4294967295, sign: false });
data.append(FP16x16 { mag: 2, sign: false });
data.append(FP16x16 { mag: 4294967295, sign: true });
data.append(FP16x16 { mag: 4294967295, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_fp8x23.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_fp8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 1, sign: true });
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 4294967295, sign: false });
data.append(FP8x23 { mag: 2, sign: false });
data.append(FP8x23 { mag: 4294967295, sign: true });
data.append(FP8x23 { mag: 4294967295, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_i32.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::operators::tensor::BoolTensorPartialEq;
use orion::operators::tensor::I32TensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_i32() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_i32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorAdd};
use orion::numbers::{NumberTrait};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_i32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_i8.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::BoolTensorPartialEq;
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::operators::tensor::BoolTensor;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::I8TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_is_pos_inf_i8() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = TensorTrait::is_inf(@input_0, Option::Some(0), Option::Some(1));
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_i8/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorAdd};
use orion::numbers::{NumberTrait};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(-1);
data.append(0);
data.append(NumberTrait::INF());
data.append(8);
data.append(NumberTrait::INF() * -1);
data.append(NumberTrait::INF());
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/is_pos_inf_i8/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::BoolTensor;
fn output_0() -> Tensor<bool> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(6);
let mut data = ArrayTrait::new();
data.append(false);
data.append(false);
data.append(true);
data.append(false);
data.append(false);
data.append(true);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp16x16_3d_default.cairo | mod input_0;
mod input_1;
mod input_2;
mod input_3;
mod output_0;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_label_encoder_fp16x16_3d_default() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let input_3 = input_3::input_3();
let z_0 = output_0::output_0();
let y_0 = input_0
.label_encoder(
default_list: Option::None,
default_tensor: Option::Some(input_1),
keys: Option::None,
keys_tensor: Option::Some(input_2),
values: Option::None,
values_tensor: Option::Some(input_3)
);
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp16x16_3d_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(9);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 393216, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp16x16_3d_default/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 6488064, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp16x16_3d_default/input_2.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_2() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 327680, sign: false });
data.append(FP16x16 { mag: 393216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp16x16_3d_default/input_3.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn input_3() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(4);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 720896, sign: false });
data.append(FP16x16 { mag: 1441792, sign: false });
data.append(FP16x16 { mag: 3604480, sign: false });
data.append(FP16x16 { mag: 4325376, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp16x16_3d_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorAdd};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(9);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 720896, sign: false });
data.append(FP16x16 { mag: 1441792, sign: false });
data.append(FP16x16 { mag: 6488064, sign: false });
data.append(FP16x16 { mag: 6488064, sign: false });
data.append(FP16x16 { mag: 3604480, sign: false });
data.append(FP16x16 { mag: 4325376, sign: false });
data.append(FP16x16 { mag: 720896, sign: false });
data.append(FP16x16 { mag: 1441792, sign: false });
data.append(FP16x16 { mag: 6488064, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp8x23_default.cairo | mod input_0;
mod input_1;
mod input_2;
mod input_3;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
#[test]
#[available_gas(2000000000)]
fn test_label_encoder_fp8x23_default() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let input_3 = input_3::input_3();
let z_0 = output_0::output_0();
let y_0 = input_0
.label_encoder(
default_list: Option::None,
default_tensor: Option::Some(input_1),
keys: Option::None,
keys_tensor: Option::Some(input_2),
values: Option::None,
values_tensor: Option::Some(input_3)
);
assert_eq(y_0, z_0);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp8x23_default/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(11);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
data.append(FP8x23 { mag: 50331648, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 58720256, sign: false });
data.append(FP8x23 { mag: 67108864, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp8x23_default/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 830472192, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp8x23_default/input_2.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_2() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 41943040, sign: false });
data.append(FP8x23 { mag: 50331648, sign: false });
data.append(FP8x23 { mag: 58720256, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp8x23_default/input_3.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn input_3() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(5);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 92274688, sign: false });
data.append(FP8x23 { mag: 184549376, sign: false });
data.append(FP8x23 { mag: 461373440, sign: false });
data.append(FP8x23 { mag: 553648128, sign: false });
data.append(FP8x23 { mag: 645922816, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/label_encoder_fp8x23_default/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorAdd};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(11);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 92274688, sign: false });
data.append(FP8x23 { mag: 184549376, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
data.append(FP8x23 { mag: 461373440, sign: false });
data.append(FP8x23 { mag: 553648128, sign: false });
data.append(FP8x23 { mag: 92274688, sign: false });
data.append(FP8x23 { mag: 184549376, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
data.append(FP8x23 { mag: 645922816, sign: false });
data.append(FP8x23 { mag: 830472192, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| 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.