常連

### 実現したいこと

・Japanize_matplotlibを動かすこと

### 前提

Japanize_matplotlibをインストールして動かそうとしたのですが、
'distutils'ファイルが見つからない旨のメッセージが出てきて
使えませんでした。
一度消して再インストールを試みましたが結果は変わりませんでした。
正直、ここからどうすればよいか見当もつかない状況です。
distutilsが必要かなというのはなんとなくわかるのですが...

どなたか知見をお持ちの方はいますでしょうか？
よろしくお願いします。


### 発生している問題・エラーメッセージ

Traceback (most recent call last):
  File "C:\Users\○○○\Desktop\○○\python\chap_chap○○.py", line 3, in <module>
    import japanize_matplotlib
  File "C:\Users\○○○\AppData\Local\Programs\Python\Python312\Lib\site-packages\japanize_matplotlib\__init__.py", line 1, in <module>
    from japanize_matplotlib.japanize_matplotlib import japanize, get_font_path, get_font_ttf_path
  File "C:\Users\○○○\AppData\Local\Programs\Python\Python312\Lib\site-packages\japanize_matplotlib\japanize_matplotlib.py", line 5, in <module>
    from distutils.version import LooseVersion
ModuleNotFoundError: No module named 'distutils'


### 該当のソースコード

Python

ソースコード

import pandas as pd
import matplotlib.pyplot as plt
import japanize_matplotlib


df=pd.read_csv("test.csv")

df.plot()
plt.show

### 試したこと

・スペルミスの確認
・モジュールのアンインストール、再インストール

### 補足情報（FW/ツールのバージョンなど）

IDLE Shell 3.12.0


Japanize_matplotlibの動かし方について

### 実現したいこと
python3のmatplotlibに関する質問です。
pandasのデータフレームが複数用意されており、indexにはdatetime形式の年月日と時刻が入っています。
それぞれのデータフレームの長さや開始日時はすべて異なります。
これらのデータに対して次のようなグラフを作ろうと思っています。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2024-04-24/01401335-b733-44b6-bea6-1d9de48da053.png)

### 発生している問題・分からないこと
```fig.add_axes```を利用してデータ長とデータ開始時刻に合わせてグラフを書いてみたのですが、それぞれの横軸がぴったり合ってくれません(14：00のところなど)。
```fig.add_axes```がグラフ外の余白など？も含めて長さを決めているからなのかなと思っているのですが、何かいい方法はないでしょうか？



### 該当のソースコード

```python
fig = plt.figure(figsize = (16,8))
year_list = [2021, 2021, 2021, 2021, 2022, 2022, 2022, 2022, 2022, 2022, 2023, 2023, 2023, 2023, 2023]
ID_list = [17008, 18018, 20028, 20029, 16017,  16019, 16022, 20028, 20029, 22034, 20028, 22033, 22034, 22037, 22038]
places = [1,2,7,3,3,4,5,4,5,6,6,3,2,1,1] #それぞれのグラフが何段目か
plt.rcParams["font.size"] = 18

for j, year, ID in zip(places, year_list, ID_list):
    df2 = load_and_format(year,ID)　#データをロードする部分
    
    graph_left_h = int(str(df2.index[0])[11:13])　#データのinndexのはじめの値から"時"を抜き出す
    graph_left_m = int(str(df2.index[0])[14:16])　#データのinndexのはじめの値から"分"を抜き出す
    left = ((graph_left_h-6.5)+(graph_left_m/60))/12 #グラフの左端の場所を決める
    
    ax = fig.add_axes([left,1 - j*0.13,len(df2)/3600/12,0.08])
    ax.scatter(df2.index, df2["data1"]*0.5, color = "red", s = 30)

    ax.set_ylim(0,1)
    ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
    ax.xaxis.set_major_locator(mdates.HourLocator()) 
    ax.tick_params(left=False, labelleft=False)

# ここから一番下の軸を書く部分
ax_bottom = fig.add_axes([0,0,1,0.01])
ax_bottom.plot(pd.date_range("6:30:30","18:30:30", freq='H'),np.ones(13)*10)
ax_bottom.set_ylim(0,1)
ax_bottom.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
ax_bottom.xaxis.set_major_locator(mdates.HourLocator()) 
ax_bottom.tick_params(left=False, labelleft=False)
ax_bottom.spines[['left','right','top']].set_visible(False)

plt.show()
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
```sharex```を使おうかとも思ったのですが、それぞれのデータの年と日付が異なります。
時刻だけshareする方法はないでしょうか。すべてのデータの年月日を書き換えてから軸をシェアするのが最善でしょうか？

### 補足
Jupyter notebookを使っています。

時刻とデータ長に合わせてグラフの場所と長さを決めたい

### 実現したいこと
数理最適化の一つである最大被覆問題において，198個の経緯度情報(X座標，Y座標)を基にしたポ集合(点)をカバー(円に含む)する入力した値の数だけの集合とそれを中心とした円(需要範囲)が描画される実行結果を導出したい．

### 発生している問題・分からないこと
経緯度情報を持つ198個の点と入力した値の数だけの点とそれを中心とした円は描画される状態にあるが、ただ入力した値の数だけの点がランダムに配置されてしまう。全ての集合をカバーするような実行結果を算出するためにどうすればいいか知りたい。



### 該当のソースコード

```Python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import random, math, time
import pulp


#1．入力データ生成：住居の設置点を読み込む
def make_data_ad():
    #1-1．住居の位置情報を格納したcsvファイルを読み込む
    df = pd.read_csv("X_Y_data(rep_housing).csv", encoding="utf-8")
    #1-2．変数[X]に設置する住居のX座標値(経度)を代入
    X = df["X_CODE"]
    #1-3．変数[Y]に設置する住居のY座標値(緯度)を代入
    Y = df["Y_CODE"]
    #1-4．変数[X_ad]・[Y_ad],を値として返す
    return X,Y

#2．入力データ生成：資源回収物拠点の設置可能点を生成
def make_data_si(sigen, upper_x, upper_y):
    random.seed(10)
    #2-1．変数[si_X]に資源回収物拠点の設置可能点を代入
    si_X = [random.uniform(137.689, upper_x) for i in range(sigen)]
    #2-2．変数[si_X]に資源回収物拠点の設置可能点を代入
    si_Y =[random.uniform(34.682, upper_y) for i in range(sigen)]
    #2-3．[si_X]・[si_Y]を値として返す
    return [si_X, si_Y]

#3．住居と資源回収物拠点間の直線距離を測定する
def distance(si):
    ad1,ad2 = make_data_ad()
    for X_ad, Y_ad in zip(ad1, ad2):
        unit_ad = [X_ad, Y_ad]
    #3-1．変数[dx]に住居のX座標値から資源回収物拠点のX座標値を引いたx軸方向の距離を代入
    dx = unit_ad[0] - si[0]
    #3-2．変数[dy]に住居のY座標値から資源回収物拠点のY座標値を引いたy軸方向の距離を代入
    dy = unit_ad[1] - si[1]
    #3-3．x軸方向の距離の二乗とy軸方向の距離の二乗の和の平方根を求める
    return math.sqrt(dx **2 + dy **2)

#4．需要変数(二値変数)行列を生成
def make_matrix(ps, r):
    #5．許容領域内に分析対象(住居)が収まっているかを判断する
    def check(a):
        #5-1．「もし施設間の距離が許容領域の半径以下なら，要素(資源回収物拠点)を1に、それ以外は0にする」
        if a <= r:
           return 1
        else:
           return 0
    #4-1．フィールド上にプロットするためにn次正方行列に整形する用のリスト[unit_list]を作成
    unit_list = []
    #4-2．変数[n,m]に[X]と[Y]の座標値を一つにまとめたものを代入する
    for n, m in zip(ps[0], ps[1]):
    #4-3．変数[unit]に変数[n,m]を代入
        unit = (n, m)
    #4-4．変数[unit_list]に[unit]を追加
        unit_list.append(unit)
    #4‐5．[unit_list]から変数p1,p2にそれぞれX・Y座標値を代入し、変数[distance(p1, p2)]に入っている距離が許容領域の半径に収まるかどうか判断する
    return [check(distance(p1)) for p1 in unit_list]

#6．グラフ上に結果を描写する
def draw(ps, fs, r):
    #6-0．make_data_adを実行
    ad1,ad2 = make_data_ad()
    #6-1．変数[fig]にx軸、y軸における描画領域の大きさを代入する
    plt.figure(figsize=(5, 5))
    #6-2．変数[ax]にグラフの設定を保存するための枠を作成
    ax = plt.axes()
    #6-3．変数[x]にグラフ軸の数値幅と増幅単位の設定を保存
    x = np.arange(137.69, 137.76, 0.1)
    #6-4．住居の位置をグラフ上に描画する
    plt.scatter(ad1, ad2)
    #6-5．for文を用いて資源回収物拠点のX・Y座標値を変数[(i, j)］に，変数[k]に住宅の代表点から資源回収物拠点までの距離を代入する
    for k, (i, j) in zip(fs, zip(ps[0], ps[1])):
        #6-6．もし資源回収物拠点を設置する場合の描画設定を行う
        if k.value() == 1:
           #6-6-1．資源回収物拠点の色は赤色
           plt.scatter(i, j, s=2, color='red')
           #6-6-2．許容領域の描画設定を行う
           c = patches.Circle(xy=(i, j), radius=r, fill=False)
          #6-6-3．許容領域を描画する
           ax.add_patch(c)
        #6-7．資源回収物拠点を設置しない場合の設定を行う
        else:
          #6-7-1．passする
            pass
    #6-8．縦横比が同じ長さになるように調整。
    plt.axis('scaled')
    ax.set_aspect('equal')
    #6-9．グリッド線を表示
    plt.grid()
    #6-10．ⅹ軸のラベルを設定
    ax.set_xlabel('経度', fontname="MS Gothic")
    #6-11．y軸のラベルを設定
    ax.set_ylabel('緯度', fontname="MS Gothic")
    #6-12．x軸の下限値と上限値とその間隔を設定
    ax.set_xticks(np.linspace(137, 138, 10))
    #6-13．y軸の下限値と上限値とその間隔を設定
    ax.set_yticks(np.linspace(34, 35, 10))
    #6-14．グラフを描画
    plt.show()

#7．住居と資源回収物拠点における集合被覆問題を解く
def solver_set(ps, r):
    #7-1．変数[size]に資源回収物拠点のx座標値の個数を代入
    size = len(ps[0])
    #7-2．変数[cs]に「#3需要変数(二値変数)を作成」の関数を代入
    cs = make_matrix(ps, r)
    #7-3．変数[prob]に集合被覆問題を解く命令を代入
    prob = pulp.LpProblem('max-cover', sense = pulp.LpMaximize)
    #7-4．変数[fs]に変数[size]に格納されている値を変数[i]に移行し，この問題で解く際に必要となる関数を作成
    fs = [pulp.LpVariable('f{}'.format(i), lowBound=0, cat = 'Binary') for i in range(size)]
    #7-5．変数[prob]にも目的関数を追加
    prob += pulp.lpSum(fs)  
    #7-6．変数[cs]から変数[c]に制約条件を追加
    for c in cs:
        prob += pulp.lpDot(c, fs) >= fs[c]
    #7-7．変数[s]に時間計測の命令を代入
    s = time.time()
    #7-8．変数[status]に集合被覆問題が解けたかどうかの確認を行う命令を代入
    status = prob.solve()
    #7-9．変数[status]の結果を表示
    print('Status', pulp.LpStatus[status])
    #7-10．設置された資源回収物拠点の数を表示
    print('z 施設数:', prob.objective.value())
    #7-11．集合被覆問題の回答処理に掛かった時間を表示
    print('処理時間', time.time() - s)
    #7-12．関数[draw(ps, fs, r)]を実行
    draw(ps, fs, r)

#許容領域の半径
r = 0.03
#資源回収物拠点の個数
sigen = 10
#乱数上限
upper_x = 137.758
upper_y = 34.778
#実行
solver_set(make_data_si(sigen, upper_x, upper_y), r)
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
google上で「数理最適化　最大被覆問題　Python」と検索し、最大被覆問題を取り扱うPythonのプログラムを参照し、変更を加えた。
下記が変更したコードの部分
def solver_set(ps, r, sigen):
    #7-1．変数[size]に資源回収物拠点のx座標値の個数を代入
    size = len(ps[0])
    #7-2．変数[cs]に「#3需要変数(二値変数)を作成」の関数を代入
    cs = make_matrix(ps, r)
    #7-3．変数[prob]に集合被覆問題を解く命令を代入
    prob = pulp.LpProblem('max-cover', sense = pulp.LpMaximize)
    #7-4．変数[fs]に変数[size]に格納されている値を変数[i]に移行し，この問題で解く際に必要となる関数を作成
    fs = [pulp.LpVariable('f{}'.format(i), lowBound=0, cat = 'Binary') for i in range(size)]
    xs = [pulp.LpVariable('x{}'.format(i), lowBound=0, cat = 'Binary') for i in range(size)]
    prob += pulp.lpSum(xs) == sigen
    #7-6．変数[cs]から変数[c]に制約条件を追加
    for i in range(size):
        prob += pulp.lpDot(cs[i], fs) >= xs[i]
    #7-7．変数[s]に時間計測の命令を代入
    s = time.time()
    #7-8．変数[status]に集合被覆問題が解けたかどうかの確認を行う命令を代入
    status = prob.solve()
    #7-9．変数[status]の結果を表示
    print('Status', pulp.LpStatus[status])
    #7-10．設置された資源回収物拠点の数を表示
    print('z 施設数:', prob.objective.value())
    #7-11．集合被覆問題の回答処理に掛かった時間を表示
    print('処理時間', time.time() - s)
    #7-12．関数[draw(ps, fs, r)]を実行
    draw(ps, fs, r)

### 補足
PythonのVersionは2023.22.1であり、ソルバーにはpulpを使用しています。

経緯度情報を基にした最大被覆問題を解きたい

閲覧ありがとうございます。Python３でmatplotlibを用いてグラフを表示させたいのですが表示されなくて困っています。
各種サイトで検索かけて調べたのですが改善されないので詳しい方、教えていただけると助かります。plt.savefig（）は正常に動作しておりグラフが保存されているため計算部分にミスはないと思われます。

### 発生している問題・エラーメッセージ

```
グラフが表示されない
plt.show() が動いていない。
```

### 該当のソースコード

python3

T = Trange

plt.figure()
plt.plot(T, E, 'rx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle E \rangle$ per site $(J)$')
plt.savefig("E8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, SpcH, 'kx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$C_V$ per site $(\frac{J^2}{k_B^2})$')
plt.savefig("Cv8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M, 'bx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle|M|\rangle$ per site $(\mu)$')
plt.savefig("M8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M_sus, 'gx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\chi$ $(\frac{\mu}{k_B})$')
plt.savefig("chi8.pdf", format='pdf', bbox_inches='tight')

plt.tight_layout()
fig = plt.gcf()
plt.show()

np.savetxt('output.data',np.c_[T,E,SpcH,M,M_sus])
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）

```

```python
import matplotlib
matplotlib.use('Agg')
import numpy as np
from numpy import linalg as LA
import matplotlib.pyplot as plt

L = 8
ESTEP = 1000
STEP = 10000

J = 1 # J>0 to make it ferromagnetic

# Intitialize the XY network
def Init():
    return np.random.rand(L, L)*2*np.pi
    #return np.ones([L, L])

# periodic neighbor
def next(x):
    if x == L-1:
        return 0
    else:
        return x+1

# construct the bond lattice
def FreezeBonds(Ising,T,S):
    iBondFrozen = np.zeros([L,L],dtype=int)
    jBondFrozen = np.zeros([L,L],dtype=int)
    for i in np.arange(L):
        for j in np.arange(L):
            freezProb_nexti = 1 - np.exp(-2 * J * S[i][j] * S[next(i)][j] / T)
            freezProb_nextj = 1 - np.exp(-2 * J * S[i][j] * S[i][next(j)] / T)
            if (Ising[i][j] == Ising[next(i)][j]) and (np.random.rand() < freezProb_nexti):
                iBondFrozen[i][j] = 1
            if (Ising[i][j] == Ising[i][next(j)]) and (np.random.rand() < freezProb_nextj):
                jBondFrozen[i][j] = 1
    return iBondFrozen, jBondFrozen

# H-K algorithm to identify clusters
def properlabel(prp_label,i):
    while prp_label[i] != i:
        i = prp_label[i]
    return i

# Swendsen-Wang cluster
def clusterfind(iBondFrozen,jBondFrozen):
    cluster = np.zeros([L, L],dtype=int)
    prp_label = np.zeros(L**2,dtype=int)
    label = 0
    for i in np.arange(L):
        for j in np.arange(L):
            bonds = 0
            ibonds = np.zeros(4,dtype=int)
            jbonds = np.zeros(4,dtype=int)

            # check to (i-1,j)
            if (i > 0) and iBondFrozen[i-1][j]:
                ibonds[bonds] = i-1
                jbonds[bonds] = j
                bonds += 1
            # (i,j) at i edge, check to (i+1,j)
            if (i == L-1) and iBondFrozen[i][j]:
                ibonds[bonds] = 0
                jbonds[bonds] = j
                bonds += 1
            # check to (i,j-1)
            if (j > 0) and jBondFrozen[i][j-1]:
                ibonds[bonds] = i
                jbonds[bonds] = j-1
                bonds += 1
            # (i,j) at j edge, check to (i,j+1)
            if (j == L-1) and jBondFrozen[i][j]:
                ibonds[bonds] = i
                jbonds[bonds] = 0
                bonds += 1

            # check and label clusters
            if bonds == 0:
                cluster[i][j] = label
                prp_label[label] = label
                label += 1
            else:
                minlabel = label
                for b in np.arange(bonds):
                    plabel = properlabel(prp_label,cluster[ibonds[b]][jbonds[b]])
                    if minlabel > plabel:
                        minlabel = plabel

                cluster[i][j] = minlabel
                # link to the previous labels
                for b in np.arange(bonds):
                    plabel_n = cluster[ibonds[b]][jbonds[b]]
                    prp_label[plabel_n] = minlabel
                    # re-set the labels on connected sites
                    cluster[ibonds[b]][jbonds[b]] = minlabel
    return cluster, prp_label

# flip the cluster spins
def flipCluster(Ising,cluster,prp_label):
    for i in np.arange(L):
        for j in np.arange(L):
            # relabel all the cluster labels with the right ones
            cluster[i][j] = properlabel(prp_label,cluster[i][j])
    sNewChosen = np.zeros(L**2)
    sNew = np.zeros(L**2)
    flips = 0 # get the number of flipped spins to calculate the Endiff and Magdiff
    for i in np.arange(L):
        for j in np.arange(L):
            label = cluster[i][j]
            randn = np.random.rand()
            # mark the flipped label, use this label to flip all the cluster elements with this label
            if (not sNewChosen[label]) and randn < 0.5:
                sNew[label] = +1
                sNewChosen[label] = True
            elif (not sNewChosen[label]) and randn >= 0.5:
                sNew[label] = -1
                sNewChosen[label] = True

            if Ising[i][j] != sNew[label]:
                Ising[i][j] = sNew[label]
                flips += 1

    return Ising,flips

# Swendsen-Wang Algorithm in Ising model (with coupling constant dependency on sites)
# One-step for Ising
def oneMCstepIsing(Ising, S):
    [iBondFrozen, jBondFrozen] = FreezeBonds(Ising, T, S)
    [SWcluster, prp_label] = clusterfind(iBondFrozen, jBondFrozen)
    [Ising, flips] = flipCluster(Ising, SWcluster, prp_label)
    return Ising

# Decompose XY network to two Ising networks with project direction proj
def decompose(XY,proj):
    x = np.cos(XY)
    y = np.sin(XY)
    x_rot = np.multiply(x,np.cos(proj))+np.multiply(y,np.sin(proj))
    y_rot = -np.multiply(x,np.sin(proj))+np.multiply(y,np.cos(proj))
    Isingx = np.sign(x_rot)
    Isingy = np.sign(y_rot)
    S_x = np.absolute(x_rot)
    S_y = np.absolute(y_rot)
    return Isingx, Isingy, S_x, S_y

# Compose two Ising networks to XY network
def compose(Isingx_new,Isingy_new,proj,S_x, S_y):
    x_rot_new = np.multiply(Isingx_new,S_x)
    y_rot_new = np.multiply(Isingy_new,S_y)
    x_new = np.multiply(x_rot_new,np.cos(proj))-np.multiply(y_rot_new,np.sin(proj))
    y_new = np.multiply(x_rot_new,np.sin(proj))+np.multiply(y_rot_new,np.cos(proj))
    XY_new = np.arctan2(y_new,x_new)
    return XY_new

def oneMCstepXY(XY):
    proj = np.random.rand()
    [Isingx, Isingy, S_x, S_y] = decompose(XY, proj)
    Isingx_new = oneMCstepIsing(Isingx, S_x)
    #Isingy_new = oneMCstepIsing(Isingy, S_y)
    # Here we only use the flopping of Ising in projection direction, without the perpendicular direction
    #XY_new = compose(Isingx_new, Isingy_new, proj, S_x, S_y)
    XY_new = compose(Isingx_new, Isingy, proj, S_x, S_y)
    return XY_new

# Calculate the energy for XY network
def EnMag(XY):
    energy = 0
    for i in np.arange(L):
        for j in np.arange(L):
            # energy
            energy = energy - (np.cos(XY[i][j]-XY[(i-1)%L][j])+np.cos(XY[i][j]-XY[(i+1)%L][j])+np.cos(XY[i][j]-XY[i][(j-1)%L])+np.cos(XY[i][j]-XY[i][(j+1)%L]))
    magx = np.sum(np.cos(XY))
    magy = np.sum(np.sin(XY))
    mag = np.array([magx,magy])
    return energy * 0.5, LA.norm(mag)/(L**2)

# Swendsen Wang method for XY model
def SWang(T):
    XY = Init()
    # thermal steps to get the equilibrium
    for step in np.arange(ESTEP):
        XY = oneMCstepXY(XY)
    # finish with thermal equilibrium, and begin to calc observables
    E_sum = 0
    M_sum = 0
    Esq_sum = 0
    Msq_sum = 0
    for step in np.arange(STEP):
        XY = oneMCstepXY(XY)
        [E,M] = EnMag(XY)

        E_sum += E
        M_sum += M
        Esq_sum += E**2
        Msq_sum += M**2

    E_mean = E_sum/STEP/(L**2)
    M_mean = M_sum/STEP
    Esq_mean = Esq_sum/STEP/(L**4)
    Msq_mean = Msq_sum/STEP

    return XY, E_mean, M_mean, Esq_mean, Msq_mean

M = np.array([])fig = plt.gcf()
E = np.array([])
M_sus = np.array([])
SpcH = np.array([])
Trange = np.linspace(0.1, 2.5, 10)
for T in Trange:
    [Ising, E_mean, M_mean, Esq_mean, Msq_mean] = SWang(T)
    M = np.append(M, np.abs(M_mean))
    E = np.append(E, E_mean)
    M_sus = np.append(M_sus, 1/T*(Msq_mean-M_mean**2))
    SpcH = np.append(SpcH, 1/T**2*(Esq_mean-E_mean**2))

# plot the figures
T = Trange

plt.figure()
plt.plot(T, E, 'rx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle E \rangle$ per site $(J)$')
plt.savefig("E8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, SpcH, 'kx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$C_V$ per site $(\frac{J^2}{k_B^2})$')
plt.savefig("Cv8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M, 'bx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\langle|M|\rangle$ per site $(\mu)$')
plt.savefig("M8.pdf", format='pdf', bbox_inches='tight')

plt.figure()
plt.plot(T, M_sus, 'gx-')
plt.xlabel(r'Temperature $(\frac{J}{k_B})$')
plt.ylabel(r'$\chi$ $(\frac{\mu}{k_B})$')
plt.savefig("chi8.pdf", format='pdf', bbox_inches='tight')

plt.tight_layout()
fig = plt.gcf()
plt.show()

np.savetxt('output.data',np.c_[T,E,SpcH,M,M_sus])


```

python matplotlib グラフが表示されない

import japanize_matplotlib　
としたところ
ModuleNotFoundError: No module named 'japanize_matplotlib'
が出ました。
anaconda　を使っているので、
conda install japanaze_matplotlib
としましたが、
下記のように出てインストールできないです。
対処方法を教えていただきたいです。

Collecting package metadata (current_repodata.json): done
Solving environment: failed with initial frozen solve. Retrying with flexible solve.
Collecting package metadata (repodata.json): done
Solving environment: failed with initial frozen solve. Retrying with flexible solve.

PackagesNotFoundError: The following packages are not available from current channels:

  - japanize-matplotlib

Current channels:

  - https://repo.anaconda.com/pkgs/main/win-64
  - https://repo.anaconda.com/pkgs/main/noarch
  - https://repo.anaconda.com/pkgs/r/win-64
  - https://repo.anaconda.com/pkgs/r/noarch
  - https://repo.anaconda.com/pkgs/msys2/win-64
  - https://repo.anaconda.com/pkgs/msys2/noarch

To search for alternate channels that may provide the conda package you're
looking for, navigate to

    https://anaconda.org

and use the search bar at the top of the page.

conda 経由で japanaze-matplotlib　をインストールできない

matplotlib のadd_subplot メソッドの引数の数字は何を表しているのでしょうか？
例えば、
```ここに言語を入力
fig.add_subplot(1,1,1)
```
の1,1,1はどういう意味なのでしょうか？
ここを(2,2,2)にするとグラフが小さくなったのですが、果たしてこの３つの引数は何を調節しているのでしょうか？

add_subplot メソッドの引数の数字は何を表しているのか？

### 前提・実現したいこと
Python3で、曲線を描画するプログラムを作っています。
下記プログラムを実行すると、「RuntimeWarning: overflow encountered」という
エラーメッセージが出力されます。
動作上の問題はないのですが、エラーの解消方法を教えて下さい。


### エラーメッセージ
/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:11: RuntimeWarning: overflow encountered in exp
  # This is added back by InteractiveShellApp.init_path()


### 該当のソースコード
```Python
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider, IntSlider
%matplotlib inline

def oppai(y,t):
    x_1 = (1.5 * np.exp((0.12*np.sin(t)-0.5) * (y + 0.16 *np.sin(t)) ** 2)) / (1 + np.exp(-20 * (5 * y + np.sin(t))))
    x_2 = ((1.5 + 0.8 * (y + 0.2*np.sin(t)) ** 3) * (1 + np.exp(20 * (5 * y +np.sin(t)))) ** -1)
    x_3 = (1+np.exp(-(100*(y+1)+16*np.sin(t))))
    x_4 = (0.2 * (np.exp(-(y + 1) ** 2) + 1)) / (1 + np.exp(100 * (y + 1) + 16*np.sin(t)))
    x_5 = (0.1 / np.exp(2 * (10 * y + 1.2*(2+np.sin(t))*np.sin(t)) ** 4))
    x = x_1 + (x_2 / x_3) + x_4 + x_5
    return x

t = FloatSlider(min=0.1, max=5.0, step=0.1, value=0)
y = np.arange(-3, 3.01, 0.01)

@interact(t=t)
def plot_oppai(t):
    x = oppai(y,t)
    plt.figure(figsize=(10,9))
    plt.axes().set_aspect('equal', 'datalim')
    plt.grid()
    plt.plot(x, y, 'black')
    plt.show()
```

### 試したこと
「@interact(t=t)」がエラーの原因なのかと疑っており、
Webで色々調べましたが、よく分かりませんでした。

### 補足情報（FW/ツールのバージョンなど）
なし

Pythonでエラー「RuntimeWarning: overflow encountered」の解消方法を教えて下さい

### 実現したいこと

2つのグラフがあり、その交点をプロットしたい。例えば、y=cos xとy=cos(π cos x)の交点を自動的にもとめて、プロットしたいです。
交点の座標は簡単には求められないものです。

### 前提

y=cos xとy=cos(π cos x)の交点を自動的に算出して、プロットするようなプログラムを書きたい。Pythonで無理なら、別の言語でも大丈夫です。

np.argwhereを使ってみたものの、xの値はnp.linspaceなどで離散的に取得するので、交点となる無理数の解はリストの中に入らないため、プロットされない。

一方で、absなどで丸め誤差を利用するも、2つのグラフが接近する部分で無駄な部分にプロットされる。

そのため、複雑なグラフでは別のアプローチをとるべきなのかなと思いましたが、当方初心者で何もわかりません。調べてみたものの何もヒットしませんでしたので、ここで質問させてください。

今までは、LaTeXでグラフを書いていたのですが、LaTeXでは自動的にグラフの交点を算出するコマンドがありました。しかし、LaTeXでは複雑なグラフを書くことができず、matplotlibを使おうと思って、最近Pythonを学習し始めました。

### 発生している問題・エラーメッセージ

xの値はnp.linspaceなどで離散的に取得するので、交点となる無理数の解はリストの中に入らない。

absなどで丸め誤差を利用するも、2つのグラフが接近する部分で無駄な部分にプロットされる。

そのため、別のアプローチで交点を求めることが必要？


### 該当のソースコード

```Python
import matplotlib.pyplot as plt
import numpy as np

N = 99
x_min = 0
x_max = 2 * np.pi

def f(x):
    return np.cos(x)

def g(x):
    return np.cos(np.pi * f(x))

x = np.linspace(x_min, x_max, N)
y1 = f(x)
y2 = g(x)

idx = np.argwhere(np.sign(y1 - y2) == 0)

plt.plot(x[idx], y1[idx],'.', markersize=8)

plt.plot(x, y1)
plt.plot(x, y2)

plt.show()
```
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-05-19/7a922e6a-1b7b-42ca-8963-b6ca83f10f3c.png)

### 試したこと

・Nの数を増やしてみたものの、交点の数は増えない。
・absを使って丸め誤差を利用するも、不要な点がプロットされてしまう。

### 補足情報（FW/ツールのバージョンなど）

VS codeを使用


Matplotlib