def inverse_kinematics(self, foot):
hip_s = self.hip_base
knee_rod_s = self.knee_base
free_shin = self.shin - self.knee_offset
hip_e, shin_angle = find_left_triangle(self.hip,
free_shin,
self.hip_base,
foot,
get_b_global_angle=True)
knee = foot + (hip_e - foot) * self.shin / free_shin
knee_rod_e = find_left_triangle(self.knee_rod,
self.knee_connection_rod,
self.knee_base, knee)
if self.invalide_state(shin_angle, knee, knee_rod_e):
return None
knee_rod = (self.knee_base, knee_rod_e)
hip = (self.hip_base, hip_e)
knee_angle = get_angle(delta(knee_rod)) + np.pi / 2
hip_angle = get_angle(delta(hip)) + np.pi
return HindLegState(hip_s=hip_s,
hip_e=hip_e,
knee_rod_s=knee_rod_s,
knee_rod_e=knee_rod_e,
foot=foot,
knee=knee,
hip_angle=hip_angle,
knee_angle=knee_angle,
shin_angle=shin_angle)
def alpha17(df):
"""
Alpha#17
(((-1 * rank(ts_rank(close, 10))) * rank(delta(delta(close, 1), 1))) *
rank(ts_rank((volume / adv20), 5)))
"""
temp1 = (-1 * u.rank(u.ts_rank(df.close, 10)))
temp2 = u.rank(u.delta(u.delta(df.close, 1), 1))
temp3 = u.rank(u.ts_rank((df.volume / u.adv(df, 20)), 5))
return ((temp1 * temp2) * temp3)
def alpha24(df):
"""
Alpha#24
Can be shortened without the || (or operator) and just use the <= statement.
((((delta((sum(close, 100) / 100), 100) / delay(close, 100)) < 0.05) ||
((delta((sum(close, 100) / 100), 100) / delay(close, 100)) == 0.05)) ?
(-1 * (close - ts_min(close, 100))) : (-1 * delta(close, 3)))
"""
decision = u.delta(
(u.ts_sum(df.close, 100) / 100), 100) / u.delay(df.close, 100) <= 0.05
if_true = (-1 * (df.close - u.ts_min(df.close, 100)))
if_false = (-1 * u.delta(df.close, 3))
return pd.Series(np.where(decision, if_true, if_false), df.index)
def alpha31(df):
"""
Alpha#31
((rank(rank(rank(decay_linear((-1 * rank(rank(delta(close, 10)))), 10))))
+ rank((-1 * delta(close, 3)))) + sign(scale(correlation(adv20, low, 12))))
"""
temp1 = u.rank(
u.rank(
u.rank(
u.decay_linear((-1 * u.rank(u.rank(u.delta(df.close, 10)))),
10))))
temp2 = u.rank((-1 * u.delta(df.close, 3))) + np.sign(
u.scale(u.corr(u.adv(df, 20), df.low, 12)))
return temp1 + temp2
def alpha14(df):
"""
Alpha#14
((-1 * rank(delta(returns, 3))) * correlation(open, volume, 10))
"""
return ((-1 * u.rank(u.delta(df.returns, 3))) *
u.corr(df.open, df.volume, 10))
def alpha22(df):
"""
Alpha#22
(-1 * (delta(correlation(high, volume, 5), 5) * rank(stddev(close, 20))))
"""
return (-1 * (u.delta(u.corr(df.high, df.volume, 5), 5) *
u.rank(u.stddev(df.close, 20))))
def alpha43(df):
"""
Alpha#43
(ts_rank((volume / adv20), 20) * ts_rank((-1 * delta(close, 7)), 8))
"""
return (u.ts_rank((df.volume / u.adv(df, 20)), 20) * u.ts_rank(
(-1 * u.delta(df.close, 7)), 8))
def iteration(u, n, t, prev):
s = 0.5
g = n / 2
result = np.zeros((n + 1, n + 1))
delta_u = delta(u, n)
a = [0] + [-t * t * s * n * n] * (n - 1) + [0]
b = [1] + [1 + 2 * t * t * s * n * n] * (n - 1) + [1]
c = [0] + [-t * t * s * n * n] * (n - 1) + [0]
temp = make_matrix(n)
for k in range(1, n):
d = -(u[k] - prev[k]) * t * g + t * t * (
delta_u[k] - f(k / n, np.linspace(0, 1, n + 1)) / n / n) * n * n
d[0] = 0
d[n] = 0
temp[k] = tdma(n + 1, a, b, c, d)
temp = np.transpose(temp)
for k in range(1, n):
d = temp[k]
d[0] = 0
d[n] = 0
result[k] = tdma(n + 1, a, b, c, d)
result = np.transpose(result)
return result + 2 * u - prev
def alpha34(df):
"""
Alpha#34
rank(((1 - rank((stddev(returns, 2) / stddev(returns, 5)))) + (1 - rank(delta(close, 1)))))
"""
return u.rank(((1 - u.rank((u.stddev(df.returns, 2) / u.stddev(df.returns, 5)))) \
+ (1 - u.rank(u.delta(df.close, 1)))))
def alpha2(df):
"""
Alpha#2
(-1 * correlation(rank(delta(log(volume), 2)), rank(((close - open) / open)), 6))
"""
tmp_1 = u.rank(u.delta(np.log(df.volume), 2))
tmp_2 = u.rank(((df.close - df.open) / df.open))
return (-1 * u.corr(tmp_1, tmp_2, 6))
def alpha23(df):
"""
Alpha#23
(((sum(high, 20) / 20) < high) ? (-1 * delta(high, 2)) : 0)
"""
return pd.Series(
np.where((u.ts_sum(df.high, 20) / 20) < df.high,
(-1 * u.delta(df.high, 2)), 0), df.index)
def alpha39(df):
"""
Alpha#39
"""
temp = (-1 * u.rank(
(u.delta(df.close, 7) *
(1 - u.rank(u.decay_linear((df.volume / u.adv(df, 20)), 9))))))
return (temp * (1 + u.rank(u.ts_sum(df.returns, 250))))
def alpha11(df):
"""
Alpha#11
((rank(ts_max((vwap - close), 3)) +
rank(ts_min((vwap - close), 3))) * rank(delta(volume, 3)))
"""
temp1 = u.rank(u.ts_max((df.vwap - df.close), 3))
temp2 = u.rank(u.ts_min((df.vwap - df.close), 3))
temp3 = u.rank(u.delta(df.volume, 3))
return temp1 + (temp2 * temp3)
def alpha19(df):
"""
Alpha#19
((-1 * sign(((close - delay(close, 7)) + delta(close, 7)))) *
(1 + rank((1 + sum(returns, 250)))))
"""
temp1 = (-1 * np.sign(
((df.close - u.delay(df.close, 7)) + u.delta(df.close, 7))))
temp2 = (1 + u.rank((1 + u.ts_sum(df.returns, 250))))
return (temp1 * temp2)
def alpha10(df):
"""
Alpha#10
rank(((0 < ts_min(delta(close, 1), 4)) ? delta(close, 1) : ((ts_max(delta(close, 1), 4) < 0)
? delta(close, 1) : (-1 * delta(close, 1)))))
"""
tempd1 = u.delta(df.close, 1)
tempmin = u.ts_min(tempd1, 4)
tempmax = u.ts_max(tempd1, 4)
return u.rank(
pd.Series(
np.where(tempmin > 0, tempd1,
np.where(tempmax < 0, tempd1, (-1 * tempd1))), df.index))
def alpha29(df):
"""
Alpha#29
(min(product(rank(rank(scale(log(sum(ts_min(rank(rank((-1 * rank(delta((close - 1),
5))))), 2), 1))))), 1), 5) + ts_rank(delay((-1 * returns), 6), 5))
"""
temp1 = u.scale(
np.log(
u.ts_sum(
u.ts_min(
u.rank(u.rank((-1 * u.rank(u.delta((df.close - 1), 5))))),
2), 1)))
temp2 = u.product(u.rank(u.rank(temp1)), 1)
temp3 = u.ts_rank(u.delay((-1 * df.returns), 6), 5)
return (np.where(temp1 < temp2, temp1, temp2) + temp3)
def alpha12(df):
"""
Alpha#12
(sign(delta(volume, 1)) * (-1 * delta(close, 1)))
"""
return (np.sign(u.delta(df.volume, 1)) * (-1 * u.delta(df.close, 1)))