def softmax(out, x):
assert len(x.shape) == 2, "only support 2-dim softmax"
m, n = x.shape
k = hcl.reduce_axis(0, n)
max_elem = hcl.compute((m, ), lambda i: hcl.max(x[i, k], axis=k))
k = hcl.reduce_axis(0, n)
expsum = hcl.compute(
(m, ), lambda i: hcl.sum(hcl.exp(x[i, k] - max_elem[i]), axis=k))
return hcl.update(out,
lambda i, j: hcl.exp(x[i, j] - max_elem[i]) / expsum[i])
def elu(out, x, alpha):
assert len(x.shape) == 2, "only support 2-dim ELU"
m, n = x.shape
k = hcl.reduce_axis(0, n)
return hcl.update(
out, lambda i, j: hcl.select(x[i, j] < 0, alpha *
(hcl.exp(x[i, j]) - 1), x[i, j]))
def dynamics(self, t, state, uOpt,
dOpt): # Assume order of state is (x_a, z_a, u_r, w_r, x, z)
# Some constants for convenience
G1 = hcl.scalar(0, "G1")
F1 = hcl.scalar(0, "F1")
sigma = hcl.scalar(0, "sigma")
Phi_11 = hcl.scalar(0, "Phi_11")
Phi_12 = hcl.scalar(0, "Phi_12")
Phi_21 = hcl.scalar(0, "Phi_21")
Phi_22 = hcl.scalar(0, "Phi_22")
x1_dot = hcl.scalar(0, "x1_dot")
x2_dot = hcl.scalar(0, "x2_dot")
x3_dot = hcl.scalar(0, "x3_dot")
x4_dot = hcl.scalar(0, "x4_dot")
x5_dot = hcl.scalar(0, "x5_dot")
x6_dot = hcl.scalar(0, "x6_dot")
# Get the values
G1[0] = self.A * self.omega * hcl.exp(-self.k * state[5])
F1[0] = self.k * G1[0]
sigma[0] = self.k * state[4] - self.omega * (-t[0])
Phi_11[0] = F1[0] * (-hcl.sin(sigma[0]))
Phi_12[0] = F1[0] * hcl.cos(sigma[0])
Phi_21[0] = Phi_12[0]
Phi_22[0] = -Phi_11[0]
# Question: What is B matrix
x1_dot[0] = state[2] + G1[0] * hcl.cos(sigma[0]) + dOpt[0] - uOpt[2]
x2_dot[0] = state[3] + G1[0] * (-hcl.sin(sigma[0])) + dOpt[1] - uOpt[3]
x3_dot[0] = (1/(self.m - self.X_udot))*(-Phi_11[0]*(self.b - self.X_udot)* state[2] + (self.b - self.m)*(G1[0] * self.omega * hcl.sin(sigma[0])) +\
Phi_11[0] * (state[2] + G1*hcl.cos(sigma[0])) + Phi_21[0]*(state[3] + G1[0]*(-hcl.sin(sigma[0]))) - (self.X_u + self.X_uu * my_abs(state[2]))*state[2] + \
self.B[0,0]*uOpt[0] + self.B[0,1]*uOpt[1]) + dOpt[2]
x4_dot[0] = (1/(self.m - self.Z_wdot))*(-Phi_22*(self.b - self.Z_wdot)*state[3] + \
(self.b - self.m) * (G1 * self.omega * hcl.cos(sigma[0])) + \
Phi_12[0] * (state[2] + G1 * hcl.cos(sigma[0])) + \
Phi_22[0] * (state[3] + G1 * (-hcl.sin(sigma[0]))) - \
(-(self.W - self.Buoy)) - (self.Z_w + self.Z_ww * my_abs(state[3])) * state[3] + \
self.B[1,0] * uOpt[0] + self.B[1,1] * uOpt[1]) + \
dOpt[3]
x5_dot[0] = state[2] + G1[0] * hcl.cos(sigma[0]) + dOpt[0]
x6_dot[0] = state[3] + G1[0] * (-hcl.sin(sigma[0])) + dOpt[1]
return (x1_dot[0], x2_dot[0], x3_dot[0], x4_dot[0], x5_dot[0],
x6_dot[0])
def elu(data, alpha):
return hcl.compute(
data.shape,
lambda *x: hcl.select(data[x] < 0, alpha *
(hcl.exp(data[x]) - 1), data[x]))
def kernel_f(x):
return hcl.exp(-(x * x) / (2 * 1.5 * 1.5)) / math.sqrt(2 * 3.14159 * 1.5)
def kernel_f(x):
return hcl.cast(
hcl.Float(),
hcl.exp(-(x * x) / (2 * 1.5 * 1.5)) / sqrt(2 * 3.14159 * 1.5))
xlogterm = hcl.scalar(0)
xlogterm[0] = hcl.log(S[0] / X[0])
xpowerterm = hcl.scalar(0)
xpowerterm[0] = 0.5 * sigma[0] * sigma[0]
xnum = hcl.scalar(0)
xnum[0] = xlogterm[0] + (r[0] + xpowerterm[0]) * T[0]
xsqrtterm = hcl.scalar(0)
xsqrtterm[0] = hcl.sqrt(T[0])
xden = hcl.scalar(0)
xden[0] = sigma[0] * xsqrtterm[0]
#xdiv1 = hcl.scalar(0)
xdiv1[0] = xnum[0] / xden[0]
#xdiv2 = hcl.scalar(0)
xdiv2[0] = xdiv1[0] - xden[0]
futurevaluex = hcl.scalar(0)
futurevaluex[0] = X[0] * hcl.exp(-r[0] * T[0])
#--------------------------------------------------#
#Calculate N(d1), also N(-d1)=1 - N(d1)
d1NPrimeofX = hcl.scalar(0)
d1NPrimeofX[0] = hcl.exp(
-(xdiv1[0] * xdiv1[0]) * 0.5) * 0.39894228040143270286
d1K2 = hcl.scalar(0)
d1K2[0] = 1 / ((xdiv1[0] * 0.2316419) + 1.0)
d1K2_2 = hcl.scalar(0)
d1K2_2[0] = d1K2[0] * d1K2[0]
d1K2_3 = hcl.scalar(0)
d1K2_3[0] = d1K2_2[0] * d1K2[0]
d1K2_4 = hcl.scalar(0)
d1K2_4[0] = d1K2_3[0] * d1K2[0]
d1K2_5 = hcl.scalar(0)
d1K2_5[0] = d1K2_4[0] * d1K2[0]
def exp(input1, name='exp'):
return hcl.compute(input1.shape, lambda *x: hcl.exp(input1[x]), name=name)
def sigmoid(input1, name='sigmoid'):
return hcl.compute(input1.shape,
lambda *x: hcl.exp(input1[x]) /
(hcl.exp(input1[x]) + 1),
name=name)
