常連

注目の的

社会貢献

質問力

自己紹介

### 前提・実現したいこと
Pythonで方程式を解きたい。
具体的には、
```
P = C * ((1-(1+r)**(-n)))/r + fv*(1+r)**(-n)
```
という等式をrについて解きたい。



### 発生している問題・エラーメッセージ
```python
NotImplementedError                       Traceback (most recent call last)
<ipython-input-47-a183add313da> in <module>
      3 P, C, r, n, fv = sympy.symbols('P C r n fv')
      4 eq = sympy.Eq(P, C * ((1-1/(1+r)**n))/r + fv/(1+r)**n)
----> 5 sympy.solve(eq, r)

~\Anaconda3\lib\site-packages\sympy\solvers\solvers.py in solve(f, *symbols, **flags)
   1169     ###########################################################################
   1170     if bare_f:
-> 1171         solution = _solve(f[0], *symbols, **flags)
   1172     else:
   1173         solution = _solve_system(f, symbols, **flags)

~\Anaconda3\lib\site-packages\sympy\solvers\solvers.py in _solve(f, *symbols, **flags)
   1740 
   1741     if result is False:
-> 1742         raise NotImplementedError('\n'.join([msg, not_impl_msg % f]))
   1743 
   1744     if flags.get('simplify', True):

NotImplementedError: multiple generators [r, (r + 1)**n]
No algorithms are implemented to solve equation -C*(1 - (r + 1)**(-n))/r + P - fv*(r + 1)**(-n)
```
### 該当のソースコード
```Python
# Solve the equation for r
import sympy
from sympy import symbols

P, C, r, n, fv = sympy.symbols('P C r n fv')
eq = sympy.Eq(P, C * ((1-1/(1+r)**n))/r + fv/(1+r)**n)
sympy.solve(eq, r)
```
### 試したこと
sympyで方程式が解けることは理解したのですが、エラー吐いたためなかなか前に進まないです。自力で30分くらい格闘したので降参します。。。
pythonで方程式を解ける方がいればアドバイスをいただきたく投稿しました。

### 補足情報（FW/ツールのバージョンなど）
python==3.7
sympy==1.4

Pythonで複雑な方程式を解きたい！

以下のコードを実行したところ、実行途中でエラーになってしまい原因がわからないので質問させていただきます

遺伝的アルゴリズムでOpenAI GymのCartPoleをやろうとしています。

実行結果の画像にあるように第1世代くらいまではちゃんと実行できるのですが、それ以降にエラーが出てきてしまいます。
第3世代まで実行されることもあります。

デバッガー？を使ってプログラムを順に追ってみたのですが、エラーが起きる世代になるとmain関数内の<<<<に示したプログラムを実行した後にif __name__ = '__main__': main()のところまで急に飛んでしまいました。

プログラミングを始めて間もなくコードも汚いかもしれませんが、少しでもアドバイスがあればご教示いただけると幸いです。

以下にコード全文とエラーを貼ります。

```python
import gym
import random
import copy

# 遺伝子長 step数による
# 世代数 評価の誤差が小さくなるまで
# 選択 ランダム
# 交叉 一様交叉
# 突然変異確率 100世代毎に突然変異(とりあえずなし)
# 突然変異 撹拌（とりあえずなし）
# 個体集団 2500 indivisiual_size
# 親個体群 500 select_pop_size
# 交叉直後の子個体群 1500
# 子個体群の選択 エリート
# 選択後の子個体群 500
# 個体更新 JGG

indivisual_size = 2500 # 個体集団
poplation_size = 500 # 親の個体群のサイズ
selected_children_size = 500 # 子の個体群のサイズ
generation = 0 # 世代を初期化
ENV = 'CartPole-v0' # 学習環境
crossover_num = 3 # 交叉回数


# JGGクラス
# len, exchange, select(親個体をメモリから削除もする) 関数を実装する
class JGG:
    def __init__(self, indivisual_size):
        self.indivisual_size = indivisual_size
        self.indivisual_group = []
        self.poplation_group = []
        self.children_group = []
        self.selected_children_group = []

    def len(self):
        return len(self.indivisual_group)

    def select(self, poplation_size):
        # ランダムでindivisual_groupの中からpoplation_size分poplation_groupを取り出す
        # また、取り出したpoplation_groupはindivisual_groupから削除する
        random.shuffle(self.indivisual_group)
        self.poplation_group = self.indivisual_group[:poplation_size+1]
        del self.indivisual_group[:poplation_size+1]

        return self.poplation_group

    # 交叉する関数（とりあえず案）
    # 1個体あたり3回交叉する
    def crossover(self, crossover_num):

        # for pop(親1) in poplation_group:
            # poplation_groupから3個体をランダムで取り出して親1と交叉する
        # return children_group(1500個体あるはず)
        for pop_1 in self.poplation_group:
            pop_1_copy = copy.deepcopy(pop_1)
            for _ in range(crossover_num):
                pop_i = random.sample(self.poplation_group, 1)

                # pop_1 * pop_i
                min_pop_num = min(len(pop_1), len(pop_i[0]))
                if len(pop_1) > len(pop_i[0]):
                    pop_1_copy[-min_pop_num:] = pop_i[0]
                    self.children_group.append(pop_1_copy)
                elif len(pop_i[0]) > len(pop_1_copy):
                    pop_i[0][-min_pop_num:] = pop_1_copy
                    self.children_group.append(pop_i[0])
                else:
                    self.children_group.append(pop_1_copy)

        return self.children_group


    # crossover後に行動させてみてdone(step)を調べる
    # そしてステップ数を降順にソート
    def action_after_crossover(self):
        global env
        children_group_2 = []
        index_list = []
        step_list = []

        # print(self.children_group[:5])

        for i, child in enumerate(self.children_group):
            step = 0
            child_2 = []
            env.reset()
            for child_action in child:
                action = child_action
                state, reward, done, _ = env.step(action)
                step += 1
                child_2.append(action)
                if done:
                    break
            children_group_2.append(child_2)
            index_list.append(i)
            step_list.append(step)

        dic = dict(zip(index_list, step_list))

        self.children_group = []

        for key, _ in sorted(dic.items(), key=lambda x: -x[1]):
            self.children_group.append(children_group_2[key])

        return self.children_group


    # 優秀な子個体を選択する関数(エリート選択)
    # children_groupからランキング選択によりselected_children_groupを作る
    def elite_select(self):
        # ランキング選択方式によりselected_children_groupを作る
        self.selected_children_group = self.children_group[:selected_children_size]

        return self.selected_children_group

    def exchange(self):
        # selected_children_groupをindivisual_groupに加える
        self.indivisual_group.append(self.selected_children_group)



env = gym.make(ENV)

# メイン関数
def main():
    # フローを作成
    # indivisual_groupがたまるまでランダムに行動

    global env

    model = JGG(indivisual_size)
    for i in range(model.indivisual_size):
        actions_list = []
        env.reset()
        done = False
        while not done:
            action = env.action_space.sample()
            actions_list.append(action)
            state, reward, done, _ = env.step(action)
        model.indivisual_group.append(actions_list)

        if i % 50 == 0:
            print('episode: {}'.format(i))
    print('finished to store memory')

    islearned = False
    generation = 0
    while not islearned:
        model.select(poplation_size=poplation_size)
        model.crossover(crossover_num=crossover_num)
        model.action_after_crossover() <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        model.elite_select()
        model.exchange()

        gene_length_list = []
        for i, _ in enumerate(model.selected_children_group):
            gene_length_list.append(len(model.selected_children_group[i]))
        gene_length_average = sum(gene_length_list) / selected_children_size

        print('第 {} 世代 > 平均遺伝子長: {}'.format(generation,gene_length_average))


        if gene_length_average > 190:
            islearned = True

        generation += 1


    print('Evolved')


if __name__ == '__main__':
    main()
```

以下がエラーとなります。

![イメージ説明](dee85a6767d6d33330eb3c0a2c93502a.jpeg)

以下はエラー(下2行)から飛んだコードになります
エラーが出ている行を<<<<で示します

######time_limit.py
```
    def step(self, action):
        assert self._elapsed_steps is not None, "Cannot call env.step() before calling reset()"
        observation, reward, done, info = self.env.step(action) <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        self._elapsed_steps += 1
        if self._elapsed_steps >= self._max_episode_steps:
            info['TimeLimit.truncated'] = not done
            done = True
        return observation, reward, done, info
```

######cartpole.py
```ここに言語を入力
    def step(self, action):
        assert self.action_space.contains(action), "%r (%s) invalid"%(action, type(action)) <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        state = self.state
        x, x_dot, theta, theta_dot = state
        force = self.force_mag if action==1 else -self.force_mag
        costheta = math.cos(theta)
        sintheta = math.sin(theta)
        temp = (force + self.polemass_length * theta_dot * theta_dot * sintheta) / self.total_mass
        thetaacc = (self.gravity * sintheta - costheta* temp) / (self.length * (4.0/3.0 - self.masspole * costheta * costheta / self.total_mass))
        xacc  = temp - self.polemass_length * thetaacc * costheta / self.total_mass
        if self.kinematics_integrator == 'euler':
            x  = x + self.tau * x_dot
            x_dot = x_dot + self.tau * xacc
            theta = theta + self.tau * theta_dot
            theta_dot = theta_dot + self.tau * thetaacc
        else: # semi-implicit euler
            x_dot = x_dot + self.tau * xacc
            x  = x + self.tau * x_dot
            theta_dot = theta_dot + self.tau * thetaacc
            theta = theta + self.tau * theta_dot
        self.state = (x,x_dot,theta,theta_dot)
        done =  x < -self.x_threshold \
                or x > self.x_threshold \
                or theta < -self.theta_threshold_radians \
                or theta > self.theta_threshold_radians
        done = bool(done)

        if not done:
            reward = 1.0
        elif self.steps_beyond_done is None:
            # Pole just fell!
            self.steps_beyond_done = 0
            reward = 1.0
        else:
            if self.steps_beyond_done == 0:
                logger.warn("You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.")
            self.steps_beyond_done += 1
            reward = 0.0

        return np.array(self.state), reward, done, {}
```

pythonのプログラムが途中でエラーになってしまいます

Pyhon Numpy OpenCVを利用して道路の画像から空の色を抽出したいです。
空の色のHSV空間の青色の範囲がいまいちわからなくて困っています。
基本の空の色のHSV(BGR)を教えていただきたいです。
よろしくお願いします。