vyre 0.4.0

GPU compute intermediate representation with a standard operation library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::ir::model::expr::Expr;
use crate::ir::model::types::{BinOp, UnOp};

impl Expr {
    /// `min(a, b)` (f32).
    #[must_use]
    #[inline(always)]
    pub fn min(left: Self, right: Self) -> Self {
        Self::BinOp {
            op: BinOp::Min,
            left: Box::new(left),
            right: Box::new(right),
        }
    }

    /// `max(a, b)` (f32).
    #[must_use]
    #[inline(always)]
    pub fn max(left: Self, right: Self) -> Self {
        Self::BinOp {
            op: BinOp::Max,
            left: Box::new(left),
            right: Box::new(right),
        }
    }

    /// `floor(a)` (f32).
    #[must_use]
    #[inline(always)]
    pub fn floor(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::Floor,
            operand: Box::new(operand),
        }
    }

    /// `ceil(a)` (f32).
    #[must_use]
    #[inline(always)]
    pub fn ceil(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::Ceil,
            operand: Box::new(operand),
        }
    }

    /// `round(a)` (f32).
    #[must_use]
    #[inline(always)]
    pub fn round(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::Round,
            operand: Box::new(operand),
        }
    }

    /// `trunc(a)` (f32).
    #[must_use]
    #[inline(always)]
    pub fn trunc(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::Trunc,
            operand: Box::new(operand),
        }
    }

    /// `sign(a)` (f32).
    #[must_use]
    #[inline(always)]
    pub fn sign(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::Sign,
            operand: Box::new(operand),
        }
    }

    /// `isNan(a)` (f32) -> bool-as-u32.
    #[must_use]
    #[inline(always)]
    pub fn is_nan(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::IsNan,
            operand: Box::new(operand),
        }
    }

    /// `isInf(a)` (f32) -> bool-as-u32.
    #[must_use]
    #[inline(always)]
    pub fn is_inf(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::IsInf,
            operand: Box::new(operand),
        }
    }

    /// `isFinite(a)` (f32) -> bool-as-u32.
    #[must_use]
    #[inline(always)]
    pub fn is_finite(operand: Self) -> Self {
        Self::UnOp {
            op: UnOp::IsFinite,
            operand: Box::new(operand),
        }
    }
}