ijzer_lib 0.1.1

Library for IJzer. Provides tools for tensors, parsing syntax tree of the IJ language and transpiling it to rust code.
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

//! Enum for the operations in the AST
use std::fmt::Debug;
use crate::function_enums::{TensorBuilderEnum, UnaryMathFunctionEnum, BinaryMathFunctionEnum};

use crate::tokens::Number;

#[derive(Clone, PartialEq)]
pub enum Operation {
    Subtract,
    Negate,
    Group,
    Number(Number),
    Symbol(String),
    Assign,
    Identity,
    Nothing,
    Function(String),
    Array,
    Reduce,
    FunctionComposition(usize),
    TypeConversion,
    LambdaVariable(String),
    Apply,
    GeneralizedContraction,
    TensorBuilder(TensorBuilderEnum),
    Transpose,
    Shape,
    QR,
    Svd,
    Solve,
    Diag,
    Index,
    AssignSymbol(String),
    Reshape,
    UnaryFunction(UnaryMathFunctionEnum),
    BinaryFunction(BinaryMathFunctionEnum),
    Range,
}

impl Debug for Operation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Subtract => write!(f, "Subtract"),
            Self::Negate => write!(f, "Negate"),
            Self::Group => write!(f, "Group"),
            Self::Number(n) => write!(f, "Number({:?})", n),
            Self::Symbol(s) => write!(f, "Symbol({})", s),
            Self::Assign => write!(f, "Assign"),
            Self::Identity => write!(f, "Identity"),
            Self::Nothing => write!(f, "Nothing"),
            Self::Function(s) => write!(f, "Function({})", s),
            Self::Array => write!(f, "Array"),
            Self::Reduce => write!(f, "Reduce"),
            Self::FunctionComposition(n) => write!(f, "FunctionComposition(functions: {})", n),
            Self::TypeConversion => write!(f, "TypeConversion"),
            Self::LambdaVariable(s) => write!(f, "LambdaVariable(name: {})", s),
            Self::Apply => write!(f, "Apply"),
            Self::GeneralizedContraction => write!(f, "GeneralizedContraction"),
            Self::TensorBuilder(s) => write!(f, "TensorBuilder({})", s),
            Self::Transpose => write!(f, "Transpose"),
            Self::Shape => write!(f, "Shape"),
            Self::QR => write!(f, "qr"),
            Self::Svd => write!(f, "svd"),
            Self::Solve => write!(f, r"\"),
            Self::Diag => write!(f, "diag"),
            Self::Index => write!(f, "<|"),
            Self::AssignSymbol(s) => write!(f, "AssignSymbol({})", s),
            Self::Reshape => write!(f, "Reshape"),
            Self::UnaryFunction(s) => write!(f, "UnaryFunction({})", s),
            Self::BinaryFunction(s) => write!(f, "BinaryFunction({})", s),
            Self::Range => write!(f, "Range"),
        }
    }
}