qudit-expr 0.3.3

Accelerated and Extensible Quantum 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

use super::{codegen::CodeGenerator, module::Module};
use qudit_core::RealScalar;

use crate::Expression;

pub struct CompilableUnit<'a> {
    pub fn_name: String,
    pub exprs: &'a [Expression],
    pub variables: Vec<String>,
    pub unit_size: usize,
}

impl<'a> CompilableUnit<'a> {
    pub fn new(
        name: &str,
        exprs: &'a [Expression],
        variables: Vec<String>,
        unit_size: usize,
    ) -> Self {
        CompilableUnit {
            fn_name: name.to_string(),
            exprs,
            variables,
            unit_size,
        }
    }

    pub fn add_to_module<R: RealScalar>(&self, module: &Module<R>) {
        // println!("Adding fn_name: {} to module.", self.fn_name);
        // for expr in &self.exprs {
        //     println!("{:?}", expr);
        // }
        let mut codegen = CodeGenerator::new(module);
        codegen
            .gen_func(&self.fn_name, self.exprs, &self.variables, self.unit_size)
            .expect("Error generating function.");
    }
}

pub type DifferentiationLevel = usize;
pub const FUNCTION: DifferentiationLevel = 1;
pub const GRADIENT: DifferentiationLevel = 2;
pub const HESSIAN: DifferentiationLevel = 3;

// pub trait DifferentiationLevel {}

// struct Function {}
// impl DifferentiationLevel for Function {}
// struct Gradient {}
// impl DifferentiationLevel for Gradient {}
// struct Hessian {}
// impl DifferentiationLevel for Hessian {}

// impl DifferentiationLevel {
//     pub fn gradient_capable(&self) -> bool {
//         match self {
//             DifferentiationLevel::None => false,
//             DifferentiationLevel::Gradient => true,
//             DifferentiationLevel::Hessian => true,
//         }
//     }

//     pub fn hessian_capable(&self) -> bool {
//         match self {
//             DifferentiationLevel::None => false,
//             DifferentiationLevel::Gradient => false,
//             DifferentiationLevel::Hessian => true,
//         }
//     }
// }

pub struct ModuleBuilder<'a, R: RealScalar> {
    name: String,
    exprs: Vec<CompilableUnit<'a>>,
    _phantom_c: std::marker::PhantomData<R>,
}

impl<'a, R: RealScalar> ModuleBuilder<'a, R> {
    pub fn new(name: &str) -> Self {
        ModuleBuilder {
            name: name.to_string(),
            exprs: Vec::new(),
            _phantom_c: std::marker::PhantomData,
        }
    }

    pub fn add_unit(mut self, unit: CompilableUnit<'a>) -> Self {
        self.exprs.push(unit);
        self
    }

    pub fn build(self) -> Module<R> {
        let module = Module::new(&self.name);
        for expr in &self.exprs {
            expr.add_to_module(&module);
        }
        module
    }
}