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)))