file_path
stringlengths 7
180
| content
stringlengths 0
811k
| repo
stringclasses 11
values |
|---|---|---|
tests/nodes/linear_fp16x16.cairo | mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::nn::FP16x16NN;
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_linear_fp16x16() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp16x16/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 185755, sign: false });
data.append(FP16x16 { mag: 99924, sign: true });
data.append(FP16x16 { mag: 46055, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp16x16/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 429406, sign: false });
data.append(FP16x16 { mag: 288523, sign: false });
data.append(FP16x16 { mag: 414929, sign: false });
data.append(FP16x16 { mag: 259811, sign: true });
data.append(FP16x16 { mag: 394274, sign: false });
data.append(FP16x16 { mag: 314398, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp16x16/input_2.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_2() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 18363, sign: true });
data.append(FP16x16 { mag: 80823, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp16x16/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 467238, sign: false });
data.append(FP16x16 { mag: 1035802, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp8x23.cairo | mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::numbers::FixedTrait;
use orion::operators::nn::FP8x23NN;
#[test]
#[available_gas(2000000000)]
fn test_linear_fp8x23() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp8x23/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 55312980, sign: false });
data.append(FP8x23 { mag: 3192975, sign: true });
data.append(FP8x23 { mag: 30534236, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp8x23/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 53179762, sign: false });
data.append(FP8x23 { mag: 34716255, sign: false });
data.append(FP8x23 { mag: 6923297, sign: false });
data.append(FP8x23 { mag: 2365083, sign: true });
data.append(FP8x23 { mag: 35449593, sign: true });
data.append(FP8x23 { mag: 46253431, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp8x23/input_2.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_2() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 57085261, sign: false });
data.append(FP8x23 { mag: 10010743, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_fp8x23/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 419729535, sign: false });
data.append(FP8x23 { mag: 176269923, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i32.cairo | mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::I32NN;
use orion::operators::nn::NNTrait;
use orion::operators::tensor::I32TensorPartialEq;
use orion::numbers::FixedTrait;
#[test]
#[available_gas(2000000000)]
fn test_linear_i32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(5);
data.append(-1);
data.append(3);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i32/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(6);
data.append(6);
data.append(5);
data.append(-3);
data.append(6);
data.append(5);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i32/input_2.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_2() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(-3);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(36);
data.append(-9);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i8.cairo | mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::operators::tensor::I8TensorPartialEq;
use orion::numbers::FixedTrait;
use orion::operators::nn::I8NN;
#[test]
#[available_gas(2000000000)]
fn test_linear_i8() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i8/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(-3);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i8/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(0);
data.append(0);
data.append(-3);
data.append(-2);
data.append(2);
data.append(0);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i8/input_2.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_2() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(2);
data.append(-1);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_i8/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(2);
data.append(-3);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_u32.cairo | mod input_0;
mod input_1;
mod input_2;
mod output_0;
use orion::operators::tensor::U32TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::nn::NNTrait;
use orion::numbers::FixedTrait;
use orion::operators::nn::U32NN;
#[test]
#[available_gas(2000000000)]
fn test_linear_u32() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let input_2 = input_2::input_2();
let z = output_0::output_0();
let y = NNTrait::linear(input_0, input_1, input_2);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_u32/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorDiv};
fn input_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(1);
data.append(0);
data.append(2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_u32/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorDiv};
fn input_1() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(3);
let mut data = ArrayTrait::new();
data.append(3);
data.append(4);
data.append(5);
data.append(3);
data.append(1);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_u32/input_2.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorDiv};
fn input_2() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(4);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/linear_u32/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{U32Tensor, U32TensorDiv};
fn output_0() -> Tensor<u32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
let mut data = ArrayTrait::new();
data.append(17);
data.append(15);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/log_fp16x16.cairo | mod input_0;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorSub};
#[test]
#[available_gas(2000000000)]
fn test_log_fp16x16() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.log();
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/log_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: 1614287, sign: false });
data.append(FP16x16 { mag: 3665868, sign: false });
data.append(FP16x16 { mag: 4581929, sign: false });
data.append(FP16x16 { mag: 1000635, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/log_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: 209980, sign: false });
data.append(FP16x16 { mag: 263731, sign: false });
data.append(FP16x16 { mag: 278349, sign: false });
data.append(FP16x16 { mag: 178637, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/log_fp8x23.cairo | mod input_0;
mod output_0;
use core::array::{ArrayTrait, SpanTrait};
use orion::utils::{assert_eq, assert_seq_eq};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorSub};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_log_fp8x23() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = input_0.log();
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/log_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: 339939403, sign: false });
data.append(FP8x23 { mag: 689657480, sign: false });
data.append(FP8x23 { mag: 360525458, sign: false });
data.append(FP8x23 { mag: 745926917, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/log_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: 31053727, sign: false });
data.append(FP8x23 { mag: 36988061, sign: false });
data.append(FP8x23 { mag: 31546937, sign: false });
data.append(FP8x23 { mag: 37646001, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp16x16_axis_0.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::nn::NNTrait;
use orion::operators::nn::FP16x16NN;
#[test]
#[available_gas(2000000000)]
fn test_logsoftmax_fp16x16_axis_0() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::logsoftmax(@input_0, 0);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp16x16_axis_0/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: 71864, sign: true });
data.append(FP16x16 { mag: 148859, sign: true });
data.append(FP16x16 { mag: 72361, sign: true });
data.append(FP16x16 { mag: 31682, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp16x16_axis_0/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: 45178, sign: true });
data.append(FP16x16 { mag: 127314, sign: true });
data.append(FP16x16 { mag: 45674, sign: true });
data.append(FP16x16 { mag: 10137, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp16x16_axis_1.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::numbers::FixedTrait;
use orion::operators::tensor::FP16x16TensorPartialEq;
use orion::operators::nn::NNTrait;
use orion::operators::nn::FP16x16NN;
#[test]
#[available_gas(2000000000)]
fn test_logsoftmax_fp16x16_axis_1() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::logsoftmax(@input_0, 1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp16x16_axis_1/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: 55516, sign: true });
data.append(FP16x16 { mag: 94686, sign: false });
data.append(FP16x16 { mag: 154182, sign: false });
data.append(FP16x16 { mag: 54374, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp16x16_axis_1/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: 156513, sign: true });
data.append(FP16x16 { mag: 6310, sign: true });
data.append(FP16x16 { mag: 2664, sign: true });
data.append(FP16x16 { mag: 211221, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp8x23_axis_0.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::numbers::FixedTrait;
use orion::operators::nn::FP8x23NN;
use orion::operators::nn::NNTrait;
use orion::operators::tensor::FP8x23TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_logsoftmax_fp8x23_axis_0() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::logsoftmax(@input_0, 0);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp8x23_axis_0/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: 21668022, sign: true });
data.append(FP8x23 { mag: 1186402, sign: false });
data.append(FP8x23 { mag: 16768523, sign: true });
data.append(FP8x23 { mag: 20022676, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp8x23_axis_0/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: 8617021, sign: true });
data.append(FP8x23 { mag: 19680507, sign: true });
data.append(FP8x23 { mag: 3717522, sign: true });
data.append(FP8x23 { mag: 844233, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp8x23_axis_1.cairo | mod input_0;
mod output_0;
use orion::utils::{assert_eq, assert_seq_eq};
use orion::numbers::FixedTrait;
use orion::operators::nn::FP8x23NN;
use orion::operators::nn::NNTrait;
use orion::operators::tensor::FP8x23TensorPartialEq;
#[test]
#[available_gas(2000000000)]
fn test_logsoftmax_fp8x23_axis_1() {
let input_0 = input_0::input_0();
let z = output_0::output_0();
let y = NNTrait::logsoftmax(@input_0, 1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp8x23_axis_1/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: 13710717, sign: true });
data.append(FP8x23 { mag: 10127369, sign: true });
data.append(FP8x23 { mag: 16322929, sign: true });
data.append(FP8x23 { mag: 5550537, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/logsoftmax_fp8x23_axis_1/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: 7796112, sign: true });
data.append(FP8x23 { mag: 4212765, sign: true });
data.append(FP8x23 { mag: 12822736, sign: true });
data.append(FP8x23 { mag: 2050343, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1d.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, FP16x16TensorDiv};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp16x16_1d() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1d/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
data.append(FP16x16 { mag: 65536, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1d/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1d/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 458752, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1x2.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, FP16x16TensorDiv};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp16x16_1x2() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1x2/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1x2/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 131072, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_1x2/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 458752, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x1.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, FP16x16TensorDiv};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp16x16_2x1() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x1/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x1/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 131072, sign: false });
data.append(FP16x16 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x1/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 393216, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
data.append(FP16x16 { mag: 262144, sign: true });
data.append(FP16x16 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x2.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, FP16x16TensorDiv};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp16x16_2x2() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x2/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 196608, sign: true });
data.append(FP16x16 { mag: 65536, sign: false });
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x2/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn input_1() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 196608, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
data.append(FP16x16 { mag: 131072, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp16x16_2x2/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP16x16Tensor, FP16x16TensorDiv};
use orion::numbers::{FixedTrait, FP16x16};
fn output_0() -> Tensor<FP16x16> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP16x16 { mag: 720896, sign: true });
data.append(FP16x16 { mag: 262144, sign: false });
data.append(FP16x16 { mag: 851968, sign: false });
data.append(FP16x16 { mag: 131072, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1d.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp8x23_1d() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1d/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1d/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 16777216, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
data.append(FP8x23 { mag: 25165824, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1d/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 58720256, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1x2.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp8x23_1x2() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1x2/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1x2/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 0, sign: false });
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_1x2/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x1.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp8x23_2x1() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x1/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 25165824, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x1/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x1/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 8388608, sign: true });
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 25165824, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x2.cairo | mod input_0;
mod input_1;
mod output_0;
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::operators::tensor::FP8x23TensorPartialEq;
use orion::utils::{assert_eq, assert_seq_eq};
use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_fp8x23_2x2() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x2/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x2/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn input_1() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 25165824, sign: false });
data.append(FP8x23 { mag: 16777216, sign: false });
data.append(FP8x23 { mag: 8388608, sign: false });
data.append(FP8x23 { mag: 0, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_fp8x23_2x2/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{FP8x23Tensor, FP8x23TensorDiv};
use orion::numbers::{FixedTrait, FP8x23};
fn output_0() -> Tensor<FP8x23> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(FP8x23 { mag: 83886080, sign: false });
data.append(FP8x23 { mag: 50331648, sign: false });
data.append(FP8x23 { mag: 67108864, sign: false });
data.append(FP8x23 { mag: 33554432, sign: false });
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1d.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::I32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_i32_1d() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1d/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-96);
data.append(50);
data.append(16);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1d/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(23);
data.append(89);
data.append(6);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1d/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(2338);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1x2.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::I32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_i32_1x2() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1x2/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-86);
data.append(43);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1x2/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(125);
data.append(-59);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_1x2/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(-13287);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x1.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::I32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_i32_2x1() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x1/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(115);
data.append(-24);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x1/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-103);
data.append(-90);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x1/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-11845);
data.append(-10350);
data.append(2472);
data.append(2160);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x2.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::I32TensorPartialEq;
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_i32_2x2() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x2/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(74);
data.append(-16);
data.append(61);
data.append(-21);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x2/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn input_1() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(33);
data.append(119);
data.append(15);
data.append(113);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i32_2x2/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I32Tensor, I32TensorDiv};
fn output_0() -> Tensor<i32> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(2202);
data.append(6998);
data.append(1698);
data.append(4886);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1d.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::{I8Tensor, I8TensorDiv};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_i8_1d() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1d/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(-2);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1d/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(3);
let mut data = ArrayTrait::new();
data.append(-2);
data.append(-1);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1d/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
let mut data = ArrayTrait::new();
data.append(10);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1x2.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::{I8Tensor, I8TensorDiv};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_i8_1x2() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1x2/input_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(2);
let mut data = ArrayTrait::new();
data.append(-3);
data.append(-2);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1x2/input_1.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn input_1() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(2);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(3);
data.append(4);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_1x2/output_0.cairo | use core::array::{ArrayTrait, SpanTrait};
use orion::operators::tensor::{TensorTrait, Tensor};
use orion::operators::tensor::{I8Tensor, I8TensorDiv};
fn output_0() -> Tensor<i8> {
let mut shape = ArrayTrait::<usize>::new();
shape.append(1);
shape.append(1);
let mut data = ArrayTrait::new();
data.append(-17);
TensorTrait::new(shape.span(), data.span())
}
| https://github.com/gizatechxyz/orion |
tests/nodes/matmul_i8_2x1.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::{I8Tensor, I8TensorDiv};
use orion::operators::tensor::I8TensorPartialEq;
use orion::operators::tensor::{TensorTrait, Tensor};
#[test]
#[available_gas(2000000000)]
fn test_matmul_i8_2x1() {
let input_0 = input_0::input_0();
let input_1 = input_1::input_1();
let z = output_0::output_0();
let y = input_0.matmul(@input_1);
assert_eq(y, z);
}
| 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.