Skip to content

SimuQ Expressions

The class file describing expressions with variables.

Expressions are effectively functions taking a valuation of variables and generating (real) results. We support the natural construction of expressions, where users write +, -, *, / naturally on expressions.

These expressions will be used in representing the coefficients in machine's instruction Hamiltonians, where variables belonging to the instruction have effects on the Hamiltonian.

The basic operations are overloaded.

BaseVar

The basic variables.

The constrainsts specific to the variables are stored here, like the initial value, lower and upper bounds of them.

Source code in SimuQ/simuq/expression.py 
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
class BaseVar :
    """ The basic variables.

    The constrainsts specific to the variables are stored here,
    like the initial value, lower and upper bounds of them.
    """
    def __init__(self, mach) :
        self.mach = mach
        self.init_value = 0
        self.lower_bound = -np.inf
        self.upper_bound = np.inf

    def to_exp(self) :
        pass

    def __neg__(self) :
        return -self.to_exp()

    def __add__(self, other) :
        return self.to_exp() + other

    def __mul__(self, other) :
        return self.to_exp() * other

    def __sub__(self, other) :
        return self.to_exp() - other

    def __truediv__(self, other) :
        return self.to_exp() / other

Expression

The expressions.

It is effectively a function taking a valuation of global variables and local variables and generating a number.

Source code in SimuQ/simuq/expression.py 
 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
class Expression :
    """ The expressions.

    It is effectively a function taking a valuation of global variables
    and local variables and generating a number.
    """
    def __init__(self, mach, exp) :
        self.mach = mach
        self.exp = exp

    @classmethod
    def unit(cls, mach) :
        exp = lambda gvars, lvars : 1
        return cls(mach, exp)

    @classmethod
    def id_gvar(cls, mach, index) :
        exp = lambda gvars, lvars : gvars[index]
        return cls(mach, exp)

    @classmethod
    def id_lvar(cls, mach, index) :
        exp = lambda gvars, lvars : lvars[index]
        return cls(mach, exp)

    @classmethod
    def cos(cls, e) :
        if type(e) == int  or  type(e) == float  or  type(e) == complex :
            return math.cos(e)
        if isinstance(e, BaseVar) :
            e = e.to_exp()
        exp = lambda gvars, lvars : math.cos(e.exp(gvars, lvars))
        return cls(e.mach, exp)

    @classmethod
    def sin(cls, e) :
        if type(e) == int  or  type(e) == float  or  type(e) == complex :
            return math.sin(e)
        if isinstance(e, BaseVar) :
            e = e.to_exp()
        exp = lambda gvars, lvars : math.sin(e.exp(gvars, lvars))
        return cls(e.mach, exp)

    def __neg__(self) :
        exp = lambda gvars, lvars : -self.exp(gvars, lvars)
        e = Expression(self.mach, exp)
        return e

    def __add__(self, other) :
        if type(other) == int  or  type(other) == float  or  type(other) == complex :
            exp = lambda gvars, lvars : self.exp(gvars, lvars) + other
            e = Expression(self.mach, exp)
            return e
        if isinstance(other, BaseVar) :
            other = other.to_exp()
        if not hasattr(other, "exp") :
            return NotImplemented
        exp = lambda gvars, lvars : self.exp(gvars, lvars) + other.exp(gvars, lvars)
        e = Expression(self.mach, exp)
        return e

    def __sub__(self, other) :
        return self.__add__(other.__neg__())

    def __radd__(self, other) :
        if type(other) == int  or  type(other) == float  or  type(other) == complex :
            return self.__add__(other)
        elif isinstance(other, BaseVar) :
            other = other.to_exp()
            return self.__add__(other)
        else :
            return NotImplemented

    def __mul__(self, other) :
        if type(other) == int  or  type(other) == float  or  type(other) == complex :
            exp = lambda gvars, lvars : self.exp(gvars, lvars) * other
            e = Expression(self.mach, exp)
            return e
        if isinstance(other, BaseVar) :
            other = other.to_exp()
        if not hasattr(other, "exp") :
            return NotImplemented
        exp = lambda gvars, lvars : self.exp(gvars, lvars) * other.exp(gvars, lvars)
        e = Expression(self.mach, exp)
        return e

    def __rmul__(self, other) :
        if type(other) == int  or  type(other) == float  or  type(other) == complex :
            return self.__mul__(other)
        elif isinstance(other, BaseVar) :
            other = other.to_exp()
            return self.__mul__(other)
        else :
            return NotImplemented

    def __pow__(self, other) :
        if type(other) == int  or  type(other) == float  or  type(other) == complex :
            exp = lambda gvars, lvars : self.exp(gvars, lvars) ** other
            e = Expression(self.mach, exp)
            return e
        if isinstance(other, BaseVar) :
            other = other.to_exp()
        if not hasattr(other, "exp") :
            return NotImplemented
        exp = lambda gvars, lvars : self.exp(gvars, lvars) ** other.exp(gvars, lvars)
        e = Expression(self.mach, exp)
        return e

    def __truediv__(self, other) :
        if type(other) == int  or  type(other) == float  or  type(other) == complex :
            exp = lambda gvars, lvars : self.exp(gvars, lvars) / other
            e = Expression(self.mach, exp)
            return e
        if isinstance(other, BaseVar) :
            other = other.to_exp()
        if not hasattr(other, "exp") :
            return NotImplemented
        exp = lambda gvars, lvars : self.exp(gvars, lvars) / other.exp(gvars, lvars)
        e = Expression(self.mach, exp)
        return e

    def __rtruediv__(self, other) :
        if type(other) == int  or  type(other) == float  or  type(other) == complex :
            exp = lambda gvars, lvars : other / self.exp(gvars, lvars)
            e = Expression(self.mach, exp)
            return e
        if isinstance(other, BaseVar) :
            other = other.to_exp()
        if not hasattr(other, "exp") :
            return NotImplemented
        exp = lambda gvars, lvars : other.exp(gvars, lvars) / self.exp(gvars, lvars)
        e = Expression(self.mach, exp)
        return e

    def exp_eval(self, gvars, lvars) :
        return self.exp(gvars, lvars)