├── 3D-animation.ipynb ├── 3D-plot.ipynb ├── A-starGraph.ipynb ├── A-starMaze.ipynb ├── ACO.ipynb ├── AdjacencyMatrix.ipynb ├── Amazon-review-bipartite.ipynb ├── Animation.ipynb ├── Artist_Func_animation.ipynb ├── AttributedGraph.ipynb ├── AttributedGraphForSimulation.ipynb ├── BFSandDFS.ipynb ├── Bellman-Ford.ipynb ├── Centrality.ipynb ├── Centrality2.ipynb ├── ClusterCheck.ipynb ├── Colab-3D.ipynb ├── ColabAnimation.ipynb ├── ColabNetwork.ipynb ├── ConfigModel.ipynb ├── CreateVisualNet.ipynb ├── DegreeCheck.ipynb ├── DegreeDistribution.ipynb ├── Density-Clustering.ipynb ├── DijkstraAlgorithm.ipynb ├── DistanceDiameter.ipynb ├── EdgeList.ipynb ├── EoN-simulation.ipynb ├── ErrorAttackTolerance.ipynb ├── ErrorAttackTolerance2.ipynb ├── EvoPDSimulation.ipynb ├── EvoPDSimulationDebug.ipynb ├── Firefly-3D.ipynb ├── Firefly2D.ipynb ├── Floyd-Warshall.ipynb ├── Game-of-Life.ipynb ├── Graphs-Layout.ipynb ├── Heatmap.ipynb ├── JupyterAnimation.ipynb ├── KnapsackGA.ipynb ├── Matplotlib-basic.ipynb ├── Matplotlib.ipynb ├── MaxFlow-MinCut.ipynb ├── MultiagentSystem.ipynb ├── NashEquilibrium.ipynb ├── NumPy-basic.ipynb ├── NumPy-calculation.ipynb ├── OOP-conception.ipynb ├── OneMaxGA.ipynb ├── PSO-OOP-animation.ipynb ├── PSO-Procedural programming.ipynb ├── Pandas-intro.ipynb ├── Pandas-intro2.ipynb ├── Pandas-intro3.ipynb ├── PyGraphviz.ipynb ├── README.md ├── RandomGraph.ipynb ├── RepeatedPDSimulation.ipynb ├── ResistanceNetworkVisualization.ipynb ├── SIR-model.ipynb ├── ScaleFreeNetwork.ipynb ├── ScatterLine.ipynb ├── SciencePlots.ipynb ├── SimpleGA.ipynb ├── SmallWorldNetwork.ipynb ├── SpatialEvolutionaryGame.ipynb ├── SymPy-basic.ipynb ├── SymPyCalculus.ipynb ├── SymPyLinearAlgebra.ipynb ├── chatgpt-create-visual-network.ipynb ├── chatgpt-network-measure.ipynb ├── chatgpt-network-model.ipynb └── seaborn.ipynb /BFSandDFS.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 幅優先探索，深さ優先探索" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[【研究で使うPython】#19 NetworkXによるネットワーク分析　⑫幅優先探索と深さ優先探索](https://youtu.be/lLvLhUg_X6I)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 4, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "BFS: [(3, 1), (3, 4), (1, 2), (1, 5), (4, 6)]\n", 29 | "DFS: [(3, 1), (1, 2), (1, 4), (4, 5), (5, 6)]\n" 30 | ] 31 | }, 32 | { 33 | "data": { 34 | "image/png": "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\n", 35 | "text/plain": [ 36 | "
" 37 | ] 38 | }, 39 | "metadata": {}, 40 | "output_type": "display_data" 41 | } 42 | ], 43 | "source": [ 44 | "%matplotlib inline\n", 45 | "import networkx as nx # NetworkXをインポート\n", 46 | "import matplotlib.pyplot as plt\n", 47 | "import numpy as np\n", 48 | "\n", 49 | "# ネットワーク生成\n", 50 | "G = nx.Graph([(1, 2), (1,3), (1,4), (1,5), (3, 4), (4,5), (4,6),(5,6)])\n", 51 | "nx.draw(G, with_labels=True) # ラベルをTrueにして番号の可視化\n", 52 | "\n", 53 | "print('BFS:',list(nx.bfs_edges(G, source=3)))\n", 54 | "print('DFS:',list(nx.dfs_edges(G, source=3)))" 55 | ] 56 | } 57 | ], 58 | "metadata": { 59 | "kernelspec": { 60 | "display_name": "Python 3", 61 | "language": "python", 62 | "name": "python3" 63 | }, 64 | "language_info": { 65 | "codemirror_mode": { 66 | "name": "ipython", 67 | "version": 3 68 | }, 69 | "file_extension": ".py", 70 | "mimetype": "text/x-python", 71 | "name": "python", 72 | "nbconvert_exporter": "python", 73 | "pygments_lexer": "ipython3", 74 | "version": "3.7.6" 75 | } 76 | }, 77 | "nbformat": 4, 78 | "nbformat_minor": 4 79 | } 80 | -------------------------------------------------------------------------------- /Bellman-Ford.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# NetworkXによるベルマンフォード法" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[NetworkXで最短経路問題　⑯ベルマンフォード法【研究で使うPython #59】](https://youtu.be/WvNV6fQdi9Q)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## 必要モジュールのインポート" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "%matplotlib inline\n", 33 | "import networkx as nx" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "## ネットワークの生成" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 5, 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "data": { 50 | "image/png": "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\n", 51 | "text/plain": [ 52 | "
" 53 | ] 54 | }, 55 | "metadata": {}, 56 | "output_type": "display_data" 57 | } 58 | ], 59 | "source": [ 60 | "G = nx.DiGraph() # 空の有向グラフ生成\n", 61 | "\n", 62 | "# 重み付きグラフの生成\n", 63 | "nodes = [0, 1, 2, 3, 4, 5] # ノード\n", 64 | "edges = [(0, 1, 5), (0, 2, 4), (0, 3, 5), (1, 4,-1), (2, 4, -1), (3, 2, -1), (3, 5, -3), (4, 5, 3), (2, 1, -2)]\n", 65 | "\n", 66 | "\n", 67 | "G.add_nodes_from(nodes)\n", 68 | "G.add_weighted_edges_from(edges)\n", 69 | "\n", 70 | "# 各ノードの座標\n", 71 | "pos = {0:(0,0), 1:(1,1), 2:(1,0), 3:(1,-1), 4:(2,1), 5:(2,-1)}\n", 72 | "\n", 73 | "# 重み（距離）の表示\n", 74 | "#nx.draw_networkx_edge_labels(G, pos)\n", 75 | "\n", 76 | "# 重みのみの表示\n", 77 | "edge_labels=dict([((u,v,),d['weight']) for u,v,d in G.edges(data=True)])\n", 78 | "nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)\n", 79 | "\n", 80 | "# 描画\n", 81 | "nx.draw(G, pos, with_labels=True)" 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "## 自作のベルマンフォード法" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 3, 94 | "metadata": {}, 95 | "outputs": [ 96 | { 97 | "name": "stdout", 98 | "output_type": "stream", 99 | "text": [ 100 | "[0, 2, 4, 5, 3, 2]\n", 101 | "[0, 2, 4, 5, 1, 2]\n", 102 | "[0, 2, 4, 5, 1, 2]\n", 103 | "[0, 2, 4, 5, 1, 2]\n", 104 | "[0, 2, 4, 5, 1, 2]\n" 105 | ] 106 | } 107 | ], 108 | "source": [ 109 | "INF = 100000 # 十分大きい値\n", 110 | "V = len(nodes) # ノード数\n", 111 | "D = [INF for i in range(V)] # 更新していく各ノードまでの最小コスト配列(全てINFで初期化)\n", 112 | "D[0] = 0 # 始点のコストを0に設定\n", 113 | "\n", 114 | "for i in range(V-1): # 負の閉路がない場合，V-1のループで終了できる\n", 115 | " for e in edges:\n", 116 | " if D[e[0]] + e[2] < D[e[1]]: # （ノードuの最小コスト＋エッジのコスト）＜（ノードvの暫定最小コスト）\n", 117 | " D[e[1]] = D[e[0]] + e[2] # ノードvの暫定最小コストを更新\n", 118 | " print(D)" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "## NetworkXの組み込み関数を使ったベルマンフォード法" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 4, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "name": "stdout", 135 | "output_type": "stream", 136 | "text": [ 137 | "({0: 0, 1: 2, 2: 4, 3: 5, 4: 1, 5: 2}, {0: [0], 1: [0, 2, 1], 2: [0, 2], 3: [0, 3], 4: [0, 2, 1, 4], 5: [0, 3, 5]})\n" 138 | ] 139 | } 140 | ], 141 | "source": [ 142 | "print(nx.single_source_bellman_ford(G, 0))" 143 | ] 144 | } 145 | ], 146 | "metadata": { 147 | "kernelspec": { 148 | "display_name": "Python 3", 149 | "language": "python", 150 | "name": "python3" 151 | }, 152 | "language_info": { 153 | "codemirror_mode": { 154 | "name": "ipython", 155 | "version": 3 156 | }, 157 | "file_extension": ".py", 158 | "mimetype": "text/x-python", 159 | "name": "python", 160 | "nbconvert_exporter": "python", 161 | "pygments_lexer": "ipython3", 162 | "version": "3.7.6" 163 | } 164 | }, 165 | "nbformat": 4, 166 | "nbformat_minor": 4 167 | } 168 | -------------------------------------------------------------------------------- /Centrality.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 中心性" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[【研究で使うPython】#16 NetworkXによるネットワーク分析　⑨中心性1](https://youtu.be/mg8H96dgZxc)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "Degree Centrality {1: 0.8, 2: 0.2, 3: 0.4, 4: 0.8, 5: 0.6000000000000001, 6: 0.4}\n", 29 | "Closeness Centrality {1: 0.8333333333333334, 2: 0.5, 3: 0.625, 4: 0.8333333333333334, 5: 0.7142857142857143, 6: 0.5555555555555556}\n", 30 | "Betweenness Centrality {1: 0.45, 2: 0.0, 3: 0.0, 4: 0.25, 5: 0.1, 6: 0.0}\n", 31 | "Eigenvector Centrality {1: 0.49860785248588163, 2: 0.1654134458609654, 3: 0.34438452462035696, 4: 0.5394778667450691, 5: 0.4536887948438781, 6: 0.3294814248104564}\n" 32 | ] 33 | }, 34 | { 35 | "data": { 36 | "image/png": "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\n", 37 | "text/plain": [ 38 | "
" 39 | ] 40 | }, 41 | "metadata": {}, 42 | "output_type": "display_data" 43 | } 44 | ], 45 | "source": [ 46 | "%matplotlib inline\n", 47 | "import networkx as nx # NetworkXをインポート\n", 48 | "import matplotlib.pyplot as plt\n", 49 | "import numpy as np\n", 50 | "\n", 51 | "# ネットワーク生成\n", 52 | "G = nx.Graph([(1, 2), (1,3), (1,4), (1,5), (3, 4), (4,5), (4,6),(5,6)])\n", 53 | "nx.draw(G, with_labels=True) # ラベルをTrueにして番号の可視化\n", 54 | "print('Degree Centrality', nx.degree_centrality(G))\n", 55 | "print('Closeness Centrality', nx.closeness_centrality(G))\n", 56 | "print('Betweenness Centrality', nx.betweenness_centrality(G))\n", 57 | "print('Eigenvector Centrality', nx.eigenvector_centrality(G))" 58 | ] 59 | } 60 | ], 61 | "metadata": { 62 | "kernelspec": { 63 | "display_name": "Python 3", 64 | "language": "python", 65 | "name": "python3" 66 | }, 67 | "language_info": { 68 | "codemirror_mode": { 69 | "name": "ipython", 70 | "version": 3 71 | }, 72 | "file_extension": ".py", 73 | "mimetype": "text/x-python", 74 | "name": "python", 75 | "nbconvert_exporter": "python", 76 | "pygments_lexer": "ipython3", 77 | "version": "3.7.6" 78 | } 79 | }, 80 | "nbformat": 4, 81 | "nbformat_minor": 4 82 | } 83 | -------------------------------------------------------------------------------- /Centrality2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 中心性" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[【研究で使うPython】#17 NetworkXによるネットワーク分析　⑩中心性2](https://youtu.be/L9XEOHOO3Ms)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "Degree Centrality {1: 0.8, 2: 0.2, 3: 0.4, 4: 0.8, 5: 0.6000000000000001, 6: 0.4}\n", 29 | "Closeness Centrality {1: 0.8333333333333334, 2: 0.5, 3: 0.625, 4: 0.8333333333333334, 5: 0.7142857142857143, 6: 0.5555555555555556}\n", 30 | "Betweenness Centrality {1: 0.45, 2: 0.0, 3: 0.0, 4: 0.25, 5: 0.1, 6: 0.0}\n", 31 | "Eigenvector Centrality {1: 0.49860785248588163, 2: 0.1654134458609654, 3: 0.34438452462035696, 4: 0.5394778667450691, 5: 0.4536887948438781, 6: 0.3294814248104564}\n" 32 | ] 33 | }, 34 | { 35 | "data": { 36 | "image/png": "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\n", 37 | "text/plain": [ 38 | "
" 39 | ] 40 | }, 41 | "metadata": {}, 42 | "output_type": "display_data" 43 | } 44 | ], 45 | "source": [ 46 | "%matplotlib inline\n", 47 | "import networkx as nx # NetworkXをインポート\n", 48 | "import matplotlib.pyplot as plt\n", 49 | "import numpy as np\n", 50 | "\n", 51 | "# ネットワーク生成\n", 52 | "G = nx.Graph([(1, 2), (1,3), (1,4), (1,5), (3, 4), (4,5), (4,6),(5,6)])\n", 53 | "nx.draw(G, with_labels=True) # ラベルをTrueにして番号の可視化\n", 54 | "print('Degree Centrality', nx.degree_centrality(G))\n", 55 | "print('Closeness Centrality', nx.closeness_centrality(G))\n", 56 | "print('Betweenness Centrality', nx.betweenness_centrality(G))\n", 57 | "print('Eigenvector Centrality', nx.eigenvector_centrality(G))" 58 | ] 59 | } 60 | ], 61 | "metadata": { 62 | "kernelspec": { 63 | "display_name": "Python 3", 64 | "language": "python", 65 | "name": "python3" 66 | }, 67 | "language_info": { 68 | "codemirror_mode": { 69 | "name": "ipython", 70 | "version": 3 71 | }, 72 | "file_extension": ".py", 73 | "mimetype": "text/x-python", 74 | "name": "python", 75 | "nbconvert_exporter": "python", 76 | "pygments_lexer": "ipython3", 77 | "version": "3.7.6" 78 | } 79 | }, 80 | "nbformat": 4, 81 | "nbformat_minor": 4 82 | } 83 | -------------------------------------------------------------------------------- /ClusterCheck.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "対応する動画」[【研究で使うPython】#10 NetworkXによるネットワーク分析　③ネットワークの密度とクラスタ係数](https://youtu.be/JYeuRl_1qG4)\n", 8 | "\n", 9 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "data": { 19 | "image/png": "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\n", 20 | "text/plain": [ 21 | "
" 22 | ] 23 | }, 24 | "metadata": {}, 25 | "output_type": "display_data" 26 | } 27 | ], 28 | "source": [ 29 | "%matplotlib inline\n", 30 | "import networkx as nx # NetworkXをインポート\n", 31 | "import matplotlib.pyplot as plt\n", 32 | "import numpy as np\n", 33 | "\n", 34 | "# ネットワーク生成\n", 35 | "G = nx.Graph([(1, 2), (1,3), (1,4), (1,5), (3, 4), (4,5), (4,6),(5,6)])\n", 36 | "nx.draw(G, with_labels=True) # ラベルをTrueにして番号の可視化" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 2, 42 | "metadata": {}, 43 | "outputs": [ 44 | { 45 | "name": "stdout", 46 | "output_type": "stream", 47 | "text": [ 48 | "0.5833333333333334\n" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "print(nx.average_clustering(G))" 54 | ] 55 | } 56 | ], 57 | "metadata": { 58 | "kernelspec": { 59 | "display_name": "Python 3", 60 | "language": "python", 61 | "name": "python3" 62 | }, 63 | "language_info": { 64 | "codemirror_mode": { 65 | "name": "ipython", 66 | "version": 3 67 | }, 68 | "file_extension": ".py", 69 | "mimetype": "text/x-python", 70 | "name": "python", 71 | "nbconvert_exporter": "python", 72 | "pygments_lexer": "ipython3", 73 | "version": "3.7.6" 74 | } 75 | }, 76 | "nbformat": 4, 77 | "nbformat_minor": 4 78 | } 79 | -------------------------------------------------------------------------------- /ConfigModel.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# コンフィグモデル" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[【研究で使うPython】#18 NetworkXによるネットワーク分析　⑪コンフィグモデル](https://youtu.be/GZSSGumxDpM)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "data": { 26 | "image/png": "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\n", 27 | "text/plain": [ 28 | "
" 29 | ] 30 | }, 31 | "metadata": {}, 32 | "output_type": "display_data" 33 | } 34 | ], 35 | "source": [ 36 | "%matplotlib inline\n", 37 | "import networkx as nx # NetworkXをインポート\n", 38 | "import matplotlib.pyplot as plt\n", 39 | "import numpy as np\n", 40 | "\n", 41 | "deg_seq = [1, 2, 2, 3, 4, 4]\n", 42 | "G = nx.configuration_model(deg_seq)\n", 43 | "nx.draw(G, with_labels=True) " 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [] 52 | } 53 | ], 54 | "metadata": { 55 | "kernelspec": { 56 | "display_name": "Python 3", 57 | "language": "python", 58 | "name": "python3" 59 | }, 60 | "language_info": { 61 | "codemirror_mode": { 62 | "name": "ipython", 63 | "version": 3 64 | }, 65 | "file_extension": ".py", 66 | "mimetype": "text/x-python", 67 | "name": "python", 68 | "nbconvert_exporter": "python", 69 | "pygments_lexer": "ipython3", 70 | "version": "3.7.6" 71 | } 72 | }, 73 | "nbformat": 4, 74 | "nbformat_minor": 4 75 | } 76 | -------------------------------------------------------------------------------- /ErrorAttackTolerance.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# nature論文再現　ネットワーク頑健性" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[【研究で使うPython】#22 Nature論文再現！ネットワークの頑健性①](https://youtu.be/EExQ-z1ks2Q)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## 直径の変化" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "outputs": [ 31 | { 32 | "name": "stdout", 33 | "output_type": "stream", 34 | "text": [ 35 | "E average degree 3.864\n", 36 | "SF average degree 3.984\n" 37 | ] 38 | }, 39 | { 40 | "data": { 41 | "text/plain": [ 42 | "" 43 | ] 44 | }, 45 | "execution_count": 1, 46 | "metadata": {}, 47 | "output_type": "execute_result" 48 | }, 49 | { 50 | "data": { 51 | "image/png": "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\n", 52 | "text/plain": [ 53 | "
" 54 | ] 55 | }, 56 | "metadata": { 57 | "needs_background": "light" 58 | }, 59 | "output_type": "display_data" 60 | } 61 | ], 62 | "source": [ 63 | "%matplotlib inline\n", 64 | "import matplotlib.pyplot as plt\n", 65 | "import numpy as np\n", 66 | "import networkx as nx\n", 67 | "\n", 68 | "N = 500 # ノードの数\n", 69 | "k = 4 # 平均次数\n", 70 | "E = N*k/2 # エッジの数\n", 71 | "\n", 72 | "x = [[], [], [], []]\n", 73 | "y = [[], [], [], []]\n", 74 | "\n", 75 | "# attack：次数が一番大きいノードを削除\n", 76 | "def remove_node_by_attack(G):\n", 77 | " mx_n = -1\n", 78 | " mx_d = -1\n", 79 | " \n", 80 | " # 最大次数ノードが複数あった時のためシャッフル\n", 81 | " ns = list(G.nodes())\n", 82 | " np.random.shuffle(ns)\n", 83 | " \n", 84 | " for n in ns:\n", 85 | " d = len(list(G.neighbors(n)))\n", 86 | " if d > mx_d:\n", 87 | " mx_n = n\n", 88 | " mx_d = d\n", 89 | " \n", 90 | " G.remove_node(mx_n)\n", 91 | "\n", 92 | "# failure：次数に関係なくランダムに削除\n", 93 | "def remove_node_by_error(G):\n", 94 | " G.remove_node(np.random.choice(G.nodes()))\n", 95 | "\n", 96 | "# 最大クラスタを返す\n", 97 | "def max_cluster(G):\n", 98 | " largest_cc = max(nx.connected_components(G), key=len)\n", 99 | " max_cluster = G.subgraph(largest_cc).copy()\n", 100 | " \n", 101 | " return max_cluster\n", 102 | "\n", 103 | "# 最大クラスターのノード数を取得\n", 104 | "def get_SMC(G):\n", 105 | " mc = max_cluster(G)\n", 106 | " return len(mc)\n", 107 | "\n", 108 | "G1=nx.erdos_renyi_graph(N,k/(N-1))# ER\n", 109 | "G2=nx.Graph.copy(G1)# ER\n", 110 | "G3=nx.barabasi_albert_graph(N,int(k/2))# SF\n", 111 | "G4=nx.Graph.copy(G3)# SF\n", 112 | "\n", 113 | "print('E average degree', nx.number_of_edges(G1)*2/N)\n", 114 | "print('SF average degree', nx.number_of_edges(G3)*2/N)\n", 115 | " \n", 116 | "del_num=0\n", 117 | "while del_num/N<=0.05:\n", 118 | " mc_failure = max_cluster(G1)\n", 119 | " y[0].append(nx.diameter(mc_failure))\n", 120 | " x[0].append(del_num/N)\n", 121 | " remove_node_by_error(G1)\n", 122 | " \n", 123 | " mc_attack = max_cluster(G2)\n", 124 | " y[1].append(nx.diameter(mc_attack))\n", 125 | " x[1].append(del_num/N)\n", 126 | " remove_node_by_attack(G2)\n", 127 | "\n", 128 | " del_num+=1\n", 129 | " \n", 130 | "\n", 131 | "del_num=0\n", 132 | "while del_num/N<=0.05:\n", 133 | " mc_failure = max_cluster(G3)\n", 134 | " y[2].append(nx.diameter(mc_failure))\n", 135 | " x[2].append(del_num/N)\n", 136 | " remove_node_by_error(G3)\n", 137 | "\n", 138 | " mc_attack = max_cluster(G4)\n", 139 | " y[3].append(nx.diameter(mc_attack))\n", 140 | " x[3].append(del_num/N)\n", 141 | " remove_node_by_attack(G4)\n", 142 | "\n", 143 | " del_num+=1\n", 144 | "\n", 145 | "plt.figure()\n", 146 | "plt.xlabel('f') #x軸の名前\n", 147 | "plt.ylabel('d') #y軸の名前\n", 148 | "plt.ylim(0,15)\n", 149 | "plt.xlim(0,0.05)\n", 150 | "plt.plot(x[0],y[0],label=\"E failure\",marker='^',c='b')\n", 151 | "plt.plot(x[1],y[1],label=\"E attack\",marker='D',c='r')\n", 152 | "plt.plot(x[2],y[2],label=\"SF failure\",marker='s',c='b')\n", 153 | "plt.plot(x[3],y[3],label=\"SF attack\",marker='o',c='r')\n", 154 | "\n", 155 | "plt.grid()\n", 156 | "plt.legend()" 157 | ] 158 | } 159 | ], 160 | "metadata": { 161 | "kernelspec": { 162 | "display_name": "Python 3", 163 | "language": "python", 164 | "name": "python3" 165 | }, 166 | "language_info": { 167 | "codemirror_mode": { 168 | "name": "ipython", 169 | "version": 3 170 | }, 171 | "file_extension": ".py", 172 | "mimetype": "text/x-python", 173 | "name": "python", 174 | "nbconvert_exporter": "python", 175 | "pygments_lexer": "ipython3", 176 | "version": "3.7.6" 177 | } 178 | }, 179 | "nbformat": 4, 180 | "nbformat_minor": 4 181 | } 182 | -------------------------------------------------------------------------------- /Floyd-Warshall.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# NetworkXによるワーシャルフロイド法" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[⑰ワーシャルフロイド法　NetworkXで最短経路問題【研究で使うPython #60】](https://youtu.be/qUICO9qz5E8)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## 必要モジュールのインポート" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "%matplotlib inline\n", 33 | "import networkx as nx" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "## ネットワークの生成" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 2, 46 | "metadata": { 47 | "scrolled": true 48 | }, 49 | "outputs": [ 50 | { 51 | "data": { 52 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAe5klEQVR4nO3de1hUBeI+8HeGAcEQTfEGKKzyQ6wBvOU1FTX1q6auK5Waa8aAeM1b6oOu7baVj5lr5gV11UrzkitpaaKiiCg3UbnNqGhoXlBQ0ABBBpiZ8/vDZGMBr8w5Z5j38zw9T8ycGd546u31zMxBIQiCACIiEoVS6gBERNaEpUtEJCKWLhGRiFi6REQiYukSEYmIpUtEJCKWLhGRiFi6REQiYukSEYmIpUtEJCKWLhGRiFi6REQiYukSEYmIpUtEJCKWLhGRiFRSBwCAvKJShJ/NQkZOIQr1BjjZq+DdwglvdXZDE8d6UscjIgsj505RSHkR87Qb+Vh7PBMxl3IBAKUGU8V99iolBAD+7Zpial9P+LVqJE1IIrIYltApkpXutsSr+CwiA3qDEY9LoFAA9iobLBrqjfHdPUTLR0SWxVI6RZLSffjDuYCSctOTD/6dg60Si4a2Z/ESURWW1Cmiv5CWdiMfn0VkPNMPBwBKyk34LCID6Vn55glGRBbJ0jpF9BfS1h7PhN5grHJ74dn9KNZGoSz3Kl5q3xfOb86ucozeYETY8UysH99FjKgkUx4eHmjQoAFsbGygUqlw5swZqSORhKrrFMFQjruRYdBfTYVJXwRVo5Z4ue8EOLSt3B1SdIqopZtXVIqYS7nVnm9ROTZBw57voOTXZAjlZdU+XhCA6Iu5uFtUWukVyNu3b8PW1haNGzc2V3SSmejoaDg7O0sdg0Si1+tx69YttGnTptLtNXWKYDJC1cAZLcYthU3Dpii5fAa5P30Ol8A1UDVq/t/jaugUcxL19EL42awa76vfrifqe/WA0sHpsc+hABCe/PB5bt26hZCQELi6uuKLL76ozahEJCMHDx5E27ZtMXToUGi12orba+oUpZ09GvV+F6pGzaFQKFHfsytUDZujNCezyrF/7BQxiLp0M3IKK72F43noDSZExKfh63njkJycDEEQYDQaERcXh6VLl9ZSUpKDJk2aICgoCAqFotLtCoUCgwYNgkKhQEhICCZNmlRxnyAIOHnyJOLj48WOS2ak1Wpha2uLgwcP4siRI2jTpg1CQkJwzqnLU3WKsfg3lN+7CbumravcpzeYkJF93xyxqyVq6RbqDbXyPNqMTPyalFTpttOnT+PcuXO18vwkD15eXggKCqpye1xcHFxcXHDnzh0MHDgQ3t7e6NOnD4CHpRsXF4fly5eLHZfMqKysDOXl5QAAg8GAS5cuYdmyZfAKWgGg4WMfKxgNyNu3HI4+A2DbpFW1xxTqy2s7co1ELV0n+9r5diOHDMKi5YFYunQp1q1bB71ej+nTp/MUg5VwcXEBADRr1gyjRo1CUlJSRekqlUqEhoYiNDRUyohUy8LDwzFu3DjY2NhgxIgR+Oyzz+Dp6YlZu1JwPfVWjY8TBBPyfv4XYKNC44GTazzOyd7WHLGrJeo5Xe8WTqinerFvaa9SwrtlAzg7O2P58uW4du0a5s6di969e9dSSpKz4uJi3L9/v+LvIyMjoVarJU5F5ta+fXu899570Gq12LVrFzw9PQE8vlMEQcDdiFUwFuej6aiFUNhUP/oedYpYRP1wRF5RKXp9fqzaczCCyQiYjMiP3QHj/btoMmQGoLSBQmlT6bh6KiXiF/SX/PPTJI0rV65g1KhRAB7+MXPcuHFYtGiRxKlIKo/rlLuH1qDszq9oPuZTKO0canwOsTtF1NMLzo710NerKY5cuF3lLR4Fcd+jIG5nxdfF56LRsNdYNOr9bsVtCgXQr11TFq4Va9OmDdLS0qSOQTJRU6cYCu6gKPUQYGOLrNV/rbi98f9Ng+Or/Sq+lqJTRP8YcNqNfIzZmIiS8qofkHgSB1sb7JrUHb5ujWo/GBHJWklJCdasWYPz58/j8uXL+OWXX5Cbm4stPx/Hp/FFFtMpvPYCEVmEwsJCuLi4oLi4uOI2Dw8PXLlyBdtPXbOYTpHkIubju3tg0dD2cLC1wf+8BbMKheLh/41YuETWzcnJCSEhIRXv27a3t8eePXugUCgsqlMkvZ5uelY+wo5nIvpiLhR4+CblRx5d+7Jfu6aY6u/JUwpEViwvLw+zZ89GbGwsnJyccO7cObz77rvYsmVLpeMsoVMkLd1H7haVIjw5CzFpmUjRZeD/+veFd8sGCOgk/VXeiUg6giBg9+7dmDlzJsaMGYNPP/0Ud+/eRUBAACIiImq8/sajTtn2czRsHBqg4yvtZNMpsijdR2JiYvDRRx8hJiZG6ihEJLFbt25h6tSp+OWXX7B582Z07979mZ9jzpw5cHNzw5w5c8yQ8PnwF1MSkawIgoBNmzbBz88Pfn5+SE5Ofq7ClStZ/GJKIiLg4YdfgoODUVhYiKioKPj6+kodqdZx6RKR5IxGI7788kt07doVQ4YMQUJCQp0sXIBLl4gkdu7cOWg0Gtjb2yMxMbHiugp1FZcuEUmirKwM//znP+Hv74/3338fx44dq/OFC3DpEpEETp8+jcDAQLi7uyMlJQVubm5SRxINly4RiebBgwf48MMPMXz4cCxcuBD79++3qsIFWLpEJJLjx4/D19cXt27dglarxdixY6v8KiZrwNMLRGRWBQUFmD9/PiIiIhAWFobhw4dLHUlSXLpEZDY///xzxW/20Ol0Vl+4AJcuEZlBbm4uZs6ciaSkJGzduhX9+vV78oOsBJcuEdUaQRCwY8cO+Pj4wNXVFenp6Szc/8GlS0S1IisrC1OmTMHVq1exb98+dO3aVepIssSlS0QvxGQyYcOGDejYsSNee+01nD17loX7GFy6RPTcMjMzERwcjAcPHiA6OrriRTOqGZcuET0zg8GA5cuXo3v37hgxYgTi4+NZuE+JS5eInolWq4VGo0GDBg1w6tQptG3bVupIFoVLl4ieSmlpKf7+97+jf//+mDRpEo4ePcrCfQ5cukT0RImJidBoNPD09ERqaipcXV2ljmSxWLpEVKPi4mIsXrwYO3fuxMqVK/H2229b5fUSahNPLxBRtaKiouDj44Pc3FxotVq88847LNxawKVLRJXk5+dj3rx5OHz4MNatW4dhw4ZJHalO4dIlogo//fQT1Go1bG1todPpWLhmwKVLRLh9+zY++OADpKSkYMeOHejTp4/UkeosLl0iKyYIArZt2wZfX194eHggLS2NhWtmXLpEVur69euYPHkybt68iQMHDqBLly5SR7IKXLpEVsZkMmHdunXo3LkzevbsiTNnzrBwRcSlS2RFLl26hKCgIJSXlyMmJgavvPKK1JGsDpcukRUwGAz4/PPP0bNnTwQEBCA2NpaFKxEuXaI6Li0tDYGBgWjcuDFOnz6NP/3pT1JHsmpcukR1lF6vx9/+9jcMHDgQ06dPR2RkJAtXBrh0ieqg+Ph4aDQatG/fHmlpaWjZsqXUkeh3LF2iOqSoqAiLFi3C7t27sWrVKowePZrXS5AZnl4gqiMiIyPh4+ODgoICaLVaBAQEsHBliEuXyML99ttvmDNnDqKjo7FhwwYMHjxY6kj0GFy6RBZsz549UKvVcHR0hFarZeFaAC5dIguUk5OD6dOnQ6fTYdeuXXj99deljkRPiUuXyIIIgoAtW7bA19cXXl5eSE1NZeFaGC5dIgtx7do1hISE4Pbt2zh06BA6deokdSR6Dly6RDJnMpmwZs0adO7cGX379kVSUhIL14Jx6RLJWEZGBoKCggAAsbGx8Pb2ljgRvSguXSIZKi8vx5IlS/D6669jzJgxOHHiBAu3juDSJZKZlJQUBAYGonnz5jh79izc3d2ljkS1iEuXSCb0ej1CQ0MxePBgzJo1CwcPHmTh1kFcukQyEBsbC41GA19fX6Snp6NFixZSRyIzYekSSej+/fsIDQ3F3r17sXr1avzlL3+ROhKZGU8vEEnk0KFDUKvVePDgAXQ6HQvXSnDpEons7t27mDNnDk6cOIFNmzZh4MCBUkciEXHpEolEEASEh4fDx8cHjRo1glarZeFaIS5dIhFkZ2dj2rRpuHDhAsLDw9GzZ0+pI5FEuHSJzEgQBHzzzTfw8/PDK6+8gpSUFBaulePSJTKTX3/9FZMmTcK9e/cQGRmJDh06SB2JZIBLl6iWGY1GfPXVV3jttdcwcOBAnDp1ioVLFbh0iWrR+fPnERQUBJVKhfj4eHh5eUkdiWSGS5eoFpSXl+PTTz9F37598de//hXHjx9n4VK1uHSJXtDZs2cRGBgIV1dXnD17Fq1bt5Y6EskYly7RcyopKcGCBQswdOhQzJs3DwcOHGDh0hOxdImeQ0xMDHx9fXHt2jVotVqMHz8eCoVC6lhkAXh6gegZFBYWYsGCBdi/fz/Wrl2LkSNHSh2JLAyXLtFTioiIgFqthsFggE6nY+HSc+HSJXqCvLw8zJo1CwkJCfjmm28wYMAAqSORBePSJaqBIAjYtWsXfHx80KxZM6Snp7Nw6YVx6RJV4+bNm5g6dSoyMzOxd+9edO/eXepIVEdw6RL9gSAI2LhxIzp06ICOHTsiOTmZhUu1ikuX6HeXL19GcHAw7t+/j2PHjsHHx0fqSFQHcemS1TMajVixYgW6deuGYcOGISEhgYVLZsOlS1ZNp9NBo9HAwcEBiYmJ8PT0lDoS1XFcumSVysrK8PHHH6Nfv37QaDQ4duwYC5dEwaVLVicpKQkajQYeHh5ISUmBm5ub1JHIirB0yWo8ePAAH330EbZt24Yvv/wSY8aM4fUSSHSyOr3g4uKCUaNGSR2D6qDo6Gj4+voiOzsbWq0WY8eOZeGSJGS1dNu0aYMpU6ZIHYPqkIKCAsyfPx8REREICwvD8OHDpY5EVk5WS9fGxgb16tWTOgbVEfv374darYZCoYBOp2PhWqHx48dj6NChUseoRCEIgiB1CKLalJubi5kzZyIpKQkbN25Ev379pI5EVEFWS5foaZSUlAB4+JHdPxIEATt27ICPjw9cXV2Rnp7OwiXZkdU5XaKamEwmFBUVYcKECXB3d8dXX31V5YWw0tJSREVFYf/+/XjttdckSkr0eLJcumFhYVJHIJlRKpWws7NDXl4ezp07h927dwOovHbt7e2xadMmFi7JmixLd+PGjVJHIBnKyspC27ZtMXPmTGzZsgV37typsnb5NjCSO1mWLv/Doep4enrCYDCgdevW8PPzw6pVqxAbGyt1LJKxuLi4am/PyclBVlaWyGkeklXpLlu2DJcvX0ZERESl2x88eIB9+/ZJlIrk4sqVK1CpVPDz80PXrl2xfv16hIaGAgAMBoPE6UiO+vTpgwkTJlT59yMnJwcTJkyQJJOsSnfr1q1o27YtWrRoAQD48ccfAQD169fH4sWLJUxGcuDu7o6GDRsiMDAQc+bMwYABA9C0aVOYTCaoVHxNmKry8fGBs7Mz3nzzTRQVFVXc3qFDB+Tk5EiSSVala2dnV+nrRysGePhCClmnRy+WGY1GFBYWIj8/H1FRUdi+fTtatGiByMhIiROSXCkUCqxYsQJDhgyBv78/rl69CgAoKiqCjY2NJJlkNQ8cHByQnJyMTp06ITY2Frm5uUhISICjoyNsbW2ljkciKy4uxtq1azFjxgw4ODjAzs4O//rXv9CkSRMAD08pLFu2DI6OjhInJbl69PrQzJkz4eHhAX9/f3To0AEXLlzAtGnTJMkkq9Jdvnw5Ro4cCVtbW7Rt2xYHDhxAYGAgTCYTNm3aJHU8ElFUVBSCg4PRq1evSm8Le1S4RqMRKpWKhUuPtWTJkoq/HzlyJAYMGIBTp07B1dUV3t7ekmSS5ceA7927h8aNG0sdgySQn5+PDz/8EJGRkVi/fr3sPjdP9KJkeaKUhWudfvzxR6jVatSrVw86nY6FSy8sOzsbeXl5UseoRFanF8g63b59GzNmzEBqaip27NiBPn36SB2J6ogvvvgCbm5umDNnjtRRKshq6WZnZ+PAgQNSxyCRCIKA7777Dr6+vmjTpg3S0tJYuFTnyWrpXrp0CcuWLcOwYcOkjkJmdv36dUyePBm3bt1CREQEOnfuLHUkIlHIaulS3WcymRAWFobOnTujV69eOH36NAuXrIqsli7VbZcuXUJQUBAMBgNOnDiB9u3bSx2JSHRcumR2BoMBn3/+OXr27ImAgACcPHmShUtWi0uXzCo1NRUajQZNmjTBmTNn4OHhIXUkIklx6ZJZ6PV6LFq0CIMGDcKMGTNw+PBhFi4RuHTJDOLj46HRaNC+fXukpaWhZcuWUkcikg2WLtWaoqIiLFy4EOHh4Vi9ejVGjx4tdSQi2eHpBaoVkZGR8PHxQWFhIXQ6HQuXqAZcuvRC7t27h7lz5yI6OhobNmzA4MGDpY5EJGtcuvTcfvjhB6jVajg6OkKr1bJwiZ4Cly49s5ycHEyfPh06nQ7/+c9/8Prrr0sdichicOnSUxMEAd9++y18fX3h5eWF1NRUFi7RM+LSpady9epVhISE4M6dOzh8+DA6duwodSQii8SlS49lMpmwevVqdOnSBf7+/khKSmLhEr0ALl2q0YULFxAUFASFQoHY2FjJfqcUUV3CpUtVlJeXY8mSJejduzfGjRuHEydOsHCJagmXLlWSnJwMjUaD5s2b4+zZs3B3d5c6ElGdwqVLAICSkhKEhoZiyJAhmD17Ng4ePMjCJTIDLl1CbGwsNBoNfH19kZ6ejubNm0sdiajOYulasfv37yM0NBR79+7FmjVrMGrUKKkjEdV5PL1gpQ4ePAi1Wo2SkhLodDoWLpFIuHStzN27dzF79mycPHkSmzdvxhtvvCF1JCKrwqVrJQRBwO7du6FWq9G4cWNotVoWLpEEuHStQHZ2NqZOnYqLFy9iz5496NGjh9SRiKwWl24dJggCvv76a/j5+UGtViMlJYWFSyQxLt066sqVKwgJCcFvv/2GI0eOwM/PT+pIRAQu3TrHaDRi5cqV6Nq1KwYNGoTExEQWLpGMcOnWIefPn4dGo4GdnR3i4+Ph5eUldSQi+h9cunVAWVkZPvnkE/Tt2xfvvfceoqOjWbhEMsWla+HOnDkDjUYDV1dXJCcno1WrVlJHIqLH4NK1UCUlJZg/fz6GDRuG+fPn48CBAyxcIgvA0rVAMTEx8PX1xY0bN6DVavHuu+9CoVBIHYuIngJPL1iQwsJCLFiwAPv370dYWBhGjBghdSQiekZcuhbiwIEDUKvVMBqN0Ol0LFwiC8WlK3N5eXmYNWsWEhIS8O2336J///5SRyKiF8ClK1OCIOD777+HWq1G8+bNkZ6ezsIlqgO4dGXo5s2bmDp1KjIzM/HTTz+hW7duUkciolrCpSsjgiBg48aN6NChAzp27Ijk5GQWLlEdw6UrE5cvX0ZwcDCKiopw7Ngx+Pj4SB2JiMyAS1diRqMRK1asQLdu3TBs2DAkJCSwcInqMC5dCel0Omg0GtSvXx+JiYnw9PSUOhIRmRmXrgTKysrw8ccfo1+/ftBoNIiKimLhElkJLl2RJSUlQaPRwMPDAykpKXBzc5M6EhGJiKUrkgcPHmDx4sXYvn07Vq5ciXfeeYfXSyCyQjy9IILo6Gj4+PggJycHOp0OY8aMYeESWSkuXTMqKCjAvHnzcPDgQaxbtw5vvvmm1JGISGJcumayf/9+qNVqKJVK6HQ6Fi4RAeDSrXW5ubn44IMPcPr0aXz33Xfw9/eXOhIRyQiXbi0RBAHbt2+Hj48PWrVqhfT0dBYuEVXBpVsLbty4gSlTpuD69ev4+eef0aVLF6kjEZFMcem+AJPJhPXr16NTp07o1q0bzpw5w8Ilosfi0n1Ov/zyC4KDg6HX63H8+HG8+uqrUkciIgvApfuMDAYDvvjiC/To0QN//vOfERcXx8IloqfGpfsM0tPTodFo0LBhQyQlJaFNmzZSRyIiC8Ol+xRKS0vx0Ucf4Y033sDkyZNx5MgRFi4RPRcu3SdISEiARqOBl5cXUlNT4eLiInUkIrJgLN0aFBcXY9GiRdi1axdWrVqFgIAAXi+BiF4YTy9U4+jRo/Dx8cG9e/eg0+nw1ltvsXCJqFZw6f5Bfn4+5s6di6NHj2L9+vUYMmSI1JGIqI7h0v3djz/+iFdffRX29vbQarUsXCIyC6tfurdv38aMGTOQmpqKnTt3ok+fPlJHIqI6zGqXriAI2Lp1K3x9fdG2bVukpaWxcInI7Kxy6V6/fh0hISHIzs5GREQEOnfuLHUkIrISVrV0TSYT1q5di06dOqF37944ffo0C5eIRGU1S/fixYsICgqC0WjEyZMn0b59e6kjEZEVksXS1ev12L17N6KionDnzh3s3LkTqamptfLc5eXlWLp0KXr16oW3336bhUtkBa5fv46dO3ciIyMDycnJ2LlzJ3Jzc6WOBQBQCIIgSB0iKysLrVu3Rr169VBeXg6lUomxY8diy5YtL/S8KSkp0Gg0cHZ2xr///W94eHjUTmAikrX169dj+vTpUCqVUCqVKCsrw759+2TxuwplUboAEBAQgL1798JkMsHe3h6pqalo167dcz2XXq/HJ598go0bN2LZsmV47733+IkyIitSUlKCli1boqCgAADg7u6OK1euQKmU/g/30if43ZIlS6BSPTzFPHTo0Ocu3Li4OHTo0AEZGRlIT0/HxIkTWbhEVsbBwQGLFy+GSqWCnZ0dli1bJovCBWS0dAGgb9++OHHiBDIyMp65dIuKirBw4UKEh4dj9erVGD16tJlSEpElKCkpQaNGjfDSSy8hLy9PNqUrq3cvLF++HCtXrnzmwo2MjMSkSZPg7+8PnU6Hxo0bmykhEVkKBwcHhIaGwsXFRTaFC8hk6eYVlSL8bBYycgpRqDfAyV4F7xZOeKuzG5o41qvxcffu3cPcuXMRHR2NDRs2YPDgwSKmJiK5et5OEYOkpZt2Ix9rj2ci5tLDt3KUGkwV99mrlBAA+Ldriql9PeHXqlGlx/7www+YMWMGAgICsGTJEjg6OoqYnIjk6EU6RSySle62xKv4LCIDeoMRj0ugUAD2KhssGuqN8d09kJ2djenTp+PcuXPYvHkzevXqJV5oIpKt5+0UsUlSug9/OBdQUm568sG/c7BVYqBzEb7/dBqCg4OxePFi2NvbmzElEVmK5+2URUPbi168opdu2o18jNmYiJJyY6Xb8/Yvh/5qGkzleti89DKcuo9GA7/K52htBCM+H9QCAf27ihmZiGSspk55pPzeTdzaPB0vefeC8/APK93nYGuDXZO6w9etkQhJHxL9Jb21xzOhN1T94Th1fwuuU75G6zm70SxgMfJPfIfSnMxKx5iUNjh6Sz6vQpI0AgMD0axZM6jVaqmjkAzU1CmP3Itcj3ot/1+19+kNRoQdz6z2PnMRtcHyikoRcym32vMtdk3doVDZ/v6VAgooYPgtu9IxggBEX8zF3aLSitsMBgO2bduGxMREMyYnOZk4cSIOHTokdQySgcd1CgAUn4+B0v4l2Lv7VXt/dZ1ibqKWbvjZrMfef/dwGK4vH41bGyfDxrExHNp2qXKMAkB4chYMBgO2bt0Kd3d3TJw4ET/88IOZUpPc9OnTh+/FJgCP7xRT6QPkn9yOl/trHvscjzpFLKJ+OCIjp7DSWzj+V5PBU9F4YAhKb2ZAf10LhY1tlWP0BhMOJWoxd6gfSktLYTAYAABRUVH44IMPzJadxOfo6Ih//OMfsLOze+rHlJSUYMuWLTh//rwZk5FcXHPxR6mh+vfd5p/4Do5+g6ByavrY59AbTMjIvm+OeNUStXQL9YYnHqNQ2sC+1asoPheN+ykRcOoyoupBtg5o2rQpbt68WXHTyy+/DE9Pz9qMSxJzcHB45k8SKZVKtGzZEmVlZWZKRXJyrdwBQNUhV3b7CvTX0tDy/a+e6nkK9eW1nKxmopauk/0zfDuTqco53Uc8XJpj76+/Ii4uDvPmzUNCQgI6derEpUuoV68eRo4cKXUMEsmVXSlIy7tV5Xb9dS0MBbeRFfY+AEAo0wOCCdl5M6stYif7qn+qNhdRS9e7hRPqqXKqnGIwFudDfy0NDp5doVDZQX81FcUXYuA8fF6V57BXKeHdsgEAoFevXoiPj0diYiKcnZ1F+WcgIvmoqVMcOwzGS+3/+4tmC5P2wFBwG40HT6vyHH/sFDGI+kJaQGe36u9QKHA/5SCy1k7EjZVj8Fv013h5QDDqe3WvcqgAIKBT5efp3r07Ty1YkbFjx6JHjx64ePEi3NzcsHnzZqkjkURq6hSlrT1sHF+u+Ethaw+Fyg429RtWOba6TjEn0T8cMem7Mzhy4fZjP6ZXE4UCGPxKc6wfX/VdDURknSytU0T/pME0f0/Yq2ye67H2KhtM9eeiJaL/srROEb10/Vo1wqKh3nCwfbZv/fBz0t6iflyPiOTP0jpFkouYP7rAhCVcEYiI5M+SOkXS6+mmZ+Uj7Hgmoi/mQoGHb1J+5NG1L/u1a4qp/p5cuET0RJbQKbL4zRF3i0oRnpyFjOz7KNSXw8neFt4tGyCgk/RXeSciyyPnTpFF6RIRWQteJ5GISEQsXSIiEbF0iYhExNIlIhIRS5eISEQsXSIiEbF0iYhExNIlIhIRS5eISEQsXSIiEbF0iYhExNIlIhIRS5eISEQsXSIiEbF0iYhE9P8BxHRNROj2vhYAAAAASUVORK5CYII=\n", 53 | "text/plain": [ 54 | "
" 55 | ] 56 | }, 57 | "metadata": {}, 58 | "output_type": "display_data" 59 | } 60 | ], 61 | "source": [ 62 | "G = nx.DiGraph() # 空の有向グラフ生成\n", 63 | "\n", 64 | "# 重み付きグラフの生成\n", 65 | "nodes = [1, 2, 3, 4] # ノード\n", 66 | "edges = [(1, 2, 8), (1, 3, -3), (2, 1, 5), (2, 4, 2), (3, 2, 4), (4, 3, 1)]\n", 67 | "\n", 68 | "G.add_nodes_from(nodes)\n", 69 | "G.add_weighted_edges_from(edges)\n", 70 | "\n", 71 | "# 各ノードの座標\n", 72 | "pos = {1:(0,1), 2:(1,1), 3:(0,0), 4:(1,0)}\n", 73 | "\n", 74 | "# 重み（距離）の表示\n", 75 | "#nx.draw_networkx_edge_labels(G, pos)\n", 76 | "\n", 77 | "# 重みのみの表示\n", 78 | "edge_labels=dict([((u,v,),d['weight']) for u,v,d in G.edges(data=True)])\n", 79 | "nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)\n", 80 | "\n", 81 | "# 描画\n", 82 | "nx.draw(G, pos, with_labels=True)" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "## 自作のワ―シャルフロイド法" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 3, 95 | "metadata": {}, 96 | "outputs": [ 97 | { 98 | "name": "stdout", 99 | "output_type": "stream", 100 | "text": [ 101 | "辺が存在するペア： [(1, 2), (1, 3), (2, 1), (2, 4), (3, 2), (4, 3)]\n", 102 | "D0行列： [[0, 8, -3, 100000], [5, 0, 100000, 2], [100000, 4, 0, 100000], [100000, 100000, 1, 0]]\n", 103 | "D 1 行列： [[0, 8, -3, 100000], [5, 0, 2, 2], [100000, 4, 0, 100000], [100000, 100000, 1, 0]]\n", 104 | "D 2 行列： [[0, 8, -3, 10], [5, 0, 2, 2], [9, 4, 0, 6], [100000, 100000, 1, 0]]\n", 105 | "D 3 行列： [[0, 1, -3, 3], [5, 0, 2, 2], [9, 4, 0, 6], [10, 5, 1, 0]]\n", 106 | "D 4 行列： [[0, 1, -3, 3], [5, 0, 2, 2], [9, 4, 0, 6], [10, 5, 1, 0]]\n", 107 | "最終結果： [[0, 1, -3, 3], [5, 0, 2, 2], [9, 4, 0, 6], [10, 5, 1, 0]]\n" 108 | ] 109 | } 110 | ], 111 | "source": [ 112 | "INF = 100000 # 十分大きい値\n", 113 | "V = len(nodes) # ノード数\n", 114 | "\n", 115 | "edges_exist = [edge[:2] for edge in edges] # 下の行で初期化する際、辺が存在するか知るために用いる\n", 116 | "print('辺が存在するペア：',edges_exist)\n", 117 | "\n", 118 | "G_array = [[edges[edges_exist.index((i+1, j+1))][2] if (i+1, j+1) in edges_exist else INF for j in range(V)] for i in range(V)] # 初期化 ※経路がない＝経路の長さが無限大\n", 119 | "\n", 120 | "# 対角成分を0で上書き\n", 121 | "for i in range(V):\n", 122 | " G_array[i][i] = 0\n", 123 | " \n", 124 | "print('D0行列：',G_array)\n", 125 | "\n", 126 | "for k in range(V): # 経由する頂点\n", 127 | " for i in range(V): # 始点\n", 128 | " for j in range(V): # 終点\n", 129 | " G_array[i][j] = min(G_array[i][j], G_array[i][k] + G_array[k][j])\n", 130 | " print('D',k+1,'行列：',G_array)\n", 131 | "\n", 132 | "print('最終結果：',G_array)" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "## NetworkXの組み込み関数を使ったワーシャルフロイド法" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 4, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "{1: {1: 0, 2: 1, 3: -3, 4: 3}, 2: {2: 0, 1: 5, 4: 2, 3: 2}, 3: {3: 0, 2: 4, 1: 9, 4: 6}, 4: {4: 0, 3: 1, 1: 10, 2: 5}}\n" 152 | ] 153 | } 154 | ], 155 | "source": [ 156 | "X = nx.floyd_warshall(G)\n", 157 | "Y = {a:dict(b) for a,b in X.items()}\n", 158 | "print(Y)" 159 | ] 160 | } 161 | ], 162 | "metadata": { 163 | "kernelspec": { 164 | "display_name": "Python 3", 165 | "language": "python", 166 | "name": "python3" 167 | }, 168 | "language_info": { 169 | "codemirror_mode": { 170 | "name": "ipython", 171 | "version": 3 172 | }, 173 | "file_extension": ".py", 174 | "mimetype": "text/x-python", 175 | "name": "python", 176 | "nbconvert_exporter": "python", 177 | "pygments_lexer": "ipython3", 178 | "version": "3.7.6" 179 | } 180 | }, 181 | "nbformat": 4, 182 | "nbformat_minor": 4 183 | } 184 | -------------------------------------------------------------------------------- /Heatmap.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 2次元ヒートマップ" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[【研究で使うPython】#5 シミュレーションやデータ解析結果の可視化に用いるグラフとアニメーションを学ぶ！](https://youtu.be/LpglzDcshWI)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 3, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "[[0.36453731 0.02972088 0.13812225 0.74594846 0.43670742 0.49960246\n", 29 | " 0.17707464 0.28533366 0.05510917 0.86218513]\n", 30 | " [0.5195973 0.08104887 0.72116418 0.95507796 0.61664102 0.37959493\n", 31 | " 0.27338273 0.21235359 0.12113531 0.94748636]\n", 32 | " [0.74849 0.8518888 0.43232231 0.86134183 0.56859941 0.67862537\n", 33 | " 0.21960506 0.31273763 0.17293013 0.40054678]\n", 34 | " [0.48155427 0.51331321 0.85873396 0.19058455 0.17315237 0.41916498\n", 35 | " 0.01054013 0.5547759 0.77786699 0.01730757]\n", 36 | " [0.29331524 0.89630605 0.47764423 0.52138595 0.97487981 0.35006942\n", 37 | " 0.9472274 0.17298785 0.15289068 0.21821068]\n", 38 | " [0.8598589 0.20770164 0.49764758 0.72424704 0.4431515 0.35411254\n", 39 | " 0.21727263 0.69582832 0.45908423 0.75637967]\n", 40 | " [0.0101693 0.246692 0.89824852 0.46710219 0.23968071 0.87293517\n", 41 | " 0.42934745 0.8615705 0.30272485 0.75536031]\n", 42 | " [0.1783512 0.28236303 0.90101873 0.2219882 0.8922805 0.96139479\n", 43 | " 0.9617255 0.93957497 0.07351275 0.98127118]\n", 44 | " [0.56414867 0.00845548 0.56229819 0.87332883 0.05463194 0.52763679\n", 45 | " 0.56806538 0.62705206 0.9590001 0.21508416]\n", 46 | " [0.1436915 0.86227666 0.56504858 0.86016228 0.84006563 0.33440341\n", 47 | " 0.13428758 0.20183399 0.45044782 0.13066955]]\n" 48 | ] 49 | }, 50 | { 51 | "data": { 52 | "image/png": "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\n", 53 | "text/plain": [ 54 | "
" 55 | ] 56 | }, 57 | "metadata": { 58 | "needs_background": "light" 59 | }, 60 | "output_type": "display_data" 61 | } 62 | ], 63 | "source": [ 64 | "%matplotlib inline\n", 65 | "\n", 66 | "import numpy as np\n", 67 | "import matplotlib.pyplot as plt\n", 68 | "\n", 69 | "# 10x10の乱数データ作成\n", 70 | "mat = np.random.rand(10,10)\n", 71 | "\n", 72 | "#print(mat)\n", 73 | "\n", 74 | "# ヒートマップ表示\n", 75 | "plt.imshow(mat)\n", 76 | "plt.colorbar()\n", 77 | "plt.show()" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "metadata": {}, 84 | "outputs": [], 85 | "source": [] 86 | } 87 | ], 88 | "metadata": { 89 | "kernelspec": { 90 | "display_name": "Python 3", 91 | "language": "python", 92 | "name": "python3" 93 | }, 94 | "language_info": { 95 | "codemirror_mode": { 96 | "name": "ipython", 97 | "version": 3 98 | }, 99 | "file_extension": ".py", 100 | "mimetype": "text/x-python", 101 | "name": "python", 102 | "nbconvert_exporter": "python", 103 | "pygments_lexer": "ipython3", 104 | "version": "3.7.6" 105 | } 106 | }, 107 | "nbformat": 4, 108 | "nbformat_minor": 4 109 | } 110 | -------------------------------------------------------------------------------- /NashEquilibrium.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# ナッシュ均衡をnashpyで見つける" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[ゲーム理論・進化ゲーム②　ナッシュ均衡　実装編【研究で使うPython #45】](https://youtu.be/OWFsvbupgrY)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## nashpyのインストール（初回のみ）" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "outputs": [ 31 | { 32 | "name": "stdout", 33 | "output_type": "stream", 34 | "text": [ 35 | "Requirement already satisfied: nashpy in c:\\users\\genki\\anaconda3\\lib\\site-packages (0.0.24)\n", 36 | "Requirement already satisfied: numpy>=1.15.4 in c:\\users\\genki\\anaconda3\\lib\\site-packages (from nashpy) (1.19.2)\n", 37 | "Requirement already satisfied: scipy>=0.19.0 in c:\\users\\genki\\anaconda3\\lib\\site-packages (from nashpy) (1.5.2)\n" 38 | ] 39 | } 40 | ], 41 | "source": [ 42 | "!pip install nashpy" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "## 必要モジュールのimport" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 2, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "import nashpy as nash\n", 59 | "import numpy as np" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "## ゲームの定義" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 3, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "text/plain": [ 77 | "Bi matrix game with payoff matrices:\n", 78 | "\n", 79 | "Row player:\n", 80 | "[[4 3]\n", 81 | " [5 2]]\n", 82 | "\n", 83 | "Column player:\n", 84 | "[[5 6]\n", 85 | " [4 3]]" 86 | ] 87 | }, 88 | "execution_count": 3, 89 | "metadata": {}, 90 | "output_type": "execute_result" 91 | } 92 | ], 93 | "source": [ 94 | "A = np.array([[4,3],[5,2]]) # A is the row player\n", 95 | "B = np.array([[5,6],[4,3]]) # B is the column player\n", 96 | "game1 = nash.Game(A,B)\n", 97 | "game1" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "## ナッシュ均衡を求める" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 4, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "name": "stdout", 114 | "output_type": "stream", 115 | "text": [ 116 | "(array([1., 0.]), array([0., 1.]))\n", 117 | "(array([0., 1.]), array([1., 0.]))\n", 118 | "(array([0.5, 0.5]), array([0.5, 0.5]))\n" 119 | ] 120 | } 121 | ], 122 | "source": [ 123 | "equilibria = game1.support_enumeration()\n", 124 | "for eq in equilibria:\n", 125 | " print(eq)" 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "## 囚人のジレンマゲームのナッシュ均衡を求める" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 5, 138 | "metadata": {}, 139 | "outputs": [ 140 | { 141 | "data": { 142 | "text/plain": [ 143 | "Bi matrix game with payoff matrices:\n", 144 | "\n", 145 | "Row player:\n", 146 | "[[3 0]\n", 147 | " [5 1]]\n", 148 | "\n", 149 | "Column player:\n", 150 | "[[3 5]\n", 151 | " [0 1]]" 152 | ] 153 | }, 154 | "execution_count": 5, 155 | "metadata": {}, 156 | "output_type": "execute_result" 157 | } 158 | ], 159 | "source": [ 160 | "A = np.array([[3,0],[5,1]]) # A is the row player\n", 161 | "B = np.array([[3,5],[0,1]]) # B is the column player\n", 162 | "prisoners_dilemma = nash.Game(A,B)\n", 163 | "prisoners_dilemma" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 6, 169 | "metadata": {}, 170 | "outputs": [ 171 | { 172 | "name": "stdout", 173 | "output_type": "stream", 174 | "text": [ 175 | "(array([0., 1.]), array([0., 1.]))\n" 176 | ] 177 | } 178 | ], 179 | "source": [ 180 | "equilibria = prisoners_dilemma.support_enumeration()\n", 181 | "for eq in equilibria:\n", 182 | " print(eq)" 183 | ] 184 | } 185 | ], 186 | "metadata": { 187 | "kernelspec": { 188 | "display_name": "Python 3", 189 | "language": "python", 190 | "name": "python3" 191 | }, 192 | "language_info": { 193 | "codemirror_mode": { 194 | "name": "ipython", 195 | "version": 3 196 | }, 197 | "file_extension": ".py", 198 | "mimetype": "text/x-python", 199 | "name": "python", 200 | "nbconvert_exporter": "python", 201 | "pygments_lexer": "ipython3", 202 | "version": "3.7.6" 203 | } 204 | }, 205 | "nbformat": 4, 206 | "nbformat_minor": 4 207 | } 208 | -------------------------------------------------------------------------------- /NumPy-basic.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# NumPy配列入門" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[NumPy配列入門　①基礎【研究で使うPython51】](https://youtu.be/w64TRDkZhu8)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 3, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "## リストとの違い" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 4, 38 | "metadata": {}, 39 | "outputs": [ 40 | { 41 | "ename": "TypeError", 42 | "evalue": "can't multiply sequence by non-int of type 'list'", 43 | "output_type": "error", 44 | "traceback": [ 45 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 46 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 47 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m6\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 48 | "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'list'" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "a = [1, 2, 3]\n", 54 | "b = [4, 5, 6]\n", 55 | "\n", 56 | "print(a * b)" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 5, 62 | "metadata": {}, 63 | "outputs": [ 64 | { 65 | "name": "stdout", 66 | "output_type": "stream", 67 | "text": [ 68 | "[ 4 10 18]\n" 69 | ] 70 | } 71 | ], 72 | "source": [ 73 | "a = np.array([1, 2, 3])\n", 74 | "b = np.array([4, 5, 6])\n", 75 | "\n", 76 | "print(a * b)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "## 基礎" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 6, 89 | "metadata": {}, 90 | "outputs": [ 91 | { 92 | "name": "stdout", 93 | "output_type": "stream", 94 | "text": [ 95 | "[1 2 3 4 5]\n", 96 | "[[10 9 8]\n", 97 | " [ 7 6 5]]\n" 98 | ] 99 | } 100 | ], 101 | "source": [ 102 | "# 1次元配列\n", 103 | "a = np.array([1, 2, 3, 4, 5])\n", 104 | "print(a)\n", 105 | "\n", 106 | "# 2次元配列\n", 107 | "b = np.array([[10, 9, 8],[7, 6, 5]])\n", 108 | "print(b)" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 7, 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "name": "stdout", 118 | "output_type": "stream", 119 | "text": [ 120 | "1\n", 121 | "2\n" 122 | ] 123 | } 124 | ], 125 | "source": [ 126 | "# 次元取得\n", 127 | "print(a.ndim)\n", 128 | "print(b.ndim)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 8, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | "[[1 2 3 4]\n", 141 | " [5 6 7 8]]\n" 142 | ] 143 | } 144 | ], 145 | "source": [ 146 | "a = np.array([[1,2,3,4],[5,6,7,8]])\n", 147 | "\n", 148 | "print(a)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 9, 154 | "metadata": {}, 155 | "outputs": [ 156 | { 157 | "name": "stdout", 158 | "output_type": "stream", 159 | "text": [ 160 | "8\n" 161 | ] 162 | } 163 | ], 164 | "source": [ 165 | "print(a[1,3]) # 1行3列目の要素（0から数えて）" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 10, 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "name": "stdout", 175 | "output_type": "stream", 176 | "text": [ 177 | "[1 2 3 4]\n", 178 | "[2 6]\n" 179 | ] 180 | } 181 | ], 182 | "source": [ 183 | "print(a[0,:]) # 0行目\n", 184 | "print(a[:,1]) # 1列目" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 11, 190 | "metadata": {}, 191 | "outputs": [ 192 | { 193 | "name": "stdout", 194 | "output_type": "stream", 195 | "text": [ 196 | "[[1 2 3 4 5 6 7 8 9]\n", 197 | " [0 0 0 0 0 0 0 0 0]]\n", 198 | "[2 4 6 8]\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "b = np.array([[1,2,3,4,5,6,7,8,9],[0,0,0,0,0,0,0,0,0]])\n", 204 | "print(b)\n", 205 | "print(b[0,1:8:2]) # 0行目、1～7列（間隔2）" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "## 初期化" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 12, 218 | "metadata": {}, 219 | "outputs": [ 220 | { 221 | "name": "stdout", 222 | "output_type": "stream", 223 | "text": [ 224 | "[[0. 0. 0. 0.]\n", 225 | " [0. 0. 0. 0.]]\n" 226 | ] 227 | } 228 | ], 229 | "source": [ 230 | "# 0で初期化\n", 231 | "print(np.zeros((2,4))) # 2行4列" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": 13, 237 | "metadata": {}, 238 | "outputs": [ 239 | { 240 | "name": "stdout", 241 | "output_type": "stream", 242 | "text": [ 243 | "[[1. 1. 1. 1.]\n", 244 | " [1. 1. 1. 1.]]\n" 245 | ] 246 | } 247 | ], 248 | "source": [ 249 | "# 1で初期化\n", 250 | "print(np.ones((2,4)))" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 14, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "name": "stdout", 260 | "output_type": "stream", 261 | "text": [ 262 | "[[5 5 5 5]\n", 263 | " [5 5 5 5]]\n" 264 | ] 265 | } 266 | ], 267 | "source": [ 268 | "# その他の数字で初期化\n", 269 | "print(np.full((2,4),5))" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": 17, 275 | "metadata": {}, 276 | "outputs": [ 277 | { 278 | "name": "stdout", 279 | "output_type": "stream", 280 | "text": [ 281 | "[[0.56246909 0.61776793 0.27956305 0.39847829]\n", 282 | " [0.95178958 0.27304361 0.82435759 0.30277672]]\n" 283 | ] 284 | } 285 | ], 286 | "source": [ 287 | "# 0.0以上、1.0未満の乱数で初期化\n", 288 | "print(np.random.rand(2,4))" 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": 20, 294 | "metadata": {}, 295 | "outputs": [ 296 | { 297 | "name": "stdout", 298 | "output_type": "stream", 299 | "text": [ 300 | "[[5 7 6 5 9 6]\n", 301 | " [9 9 6 7 9 5]]\n" 302 | ] 303 | } 304 | ], 305 | "source": [ 306 | "# 整数の乱数で初期化\n", 307 | "print(np.random.randint(5,10,size=(2,6))) # 5以上10未満の乱数で2行6列の行列を初期化" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": 21, 313 | "metadata": {}, 314 | "outputs": [ 315 | { 316 | "name": "stdout", 317 | "output_type": "stream", 318 | "text": [ 319 | "[[0. 0. 0. 0. 0.]\n", 320 | " [0. 0. 0. 0. 0.]\n", 321 | " [0. 0. 0. 0. 0.]\n", 322 | " [0. 0. 0. 0. 0.]\n", 323 | " [0. 0. 0. 0. 0.]]\n", 324 | " \n", 325 | "[[0. 0. 0. 0. 0.]\n", 326 | " [0. 1. 1. 1. 0.]\n", 327 | " [0. 1. 1. 1. 0.]\n", 328 | " [0. 1. 1. 1. 0.]\n", 329 | " [0. 0. 0. 0. 0.]]\n" 330 | ] 331 | } 332 | ], 333 | "source": [ 334 | "# 一部を変更\n", 335 | "a = np.zeros((5,5))\n", 336 | "print(a,end='\\n \\n')\n", 337 | "\n", 338 | "b = np.ones((3,3))\n", 339 | "\n", 340 | "a[1:4,1:4] = b # aの1～3行、1～3列にbを挿入\n", 341 | "print(a)" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 22, 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "name": "stdout", 351 | "output_type": "stream", 352 | "text": [ 353 | "[100 2 3]\n", 354 | "[100 2 3]\n", 355 | "[100 2 3]\n", 356 | "[1 2 3]\n" 357 | ] 358 | } 359 | ], 360 | "source": [ 361 | "# コピーの注意\n", 362 | "a = np.array([1,2,3])\n", 363 | "b = a\n", 364 | "b[0] = 100\n", 365 | "print(b)\n", 366 | "print(a) # 同じ配列を参照しているのでaも変更されてしまう\n", 367 | "\n", 368 | "a = np.array([1,2,3])\n", 369 | "b = a.copy()\n", 370 | "b[0] = 100\n", 371 | "print(b)\n", 372 | "print(a) # aの方は変更されていない" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": null, 378 | "metadata": {}, 379 | "outputs": [], 380 | "source": [] 381 | } 382 | ], 383 | "metadata": { 384 | "kernelspec": { 385 | "display_name": "Python 3", 386 | "language": "python", 387 | "name": "python3" 388 | }, 389 | "language_info": { 390 | "codemirror_mode": { 391 | "name": "ipython", 392 | "version": 3 393 | }, 394 | "file_extension": ".py", 395 | "mimetype": "text/x-python", 396 | "name": "python", 397 | "nbconvert_exporter": "python", 398 | "pygments_lexer": "ipython3", 399 | "version": "3.7.6" 400 | } 401 | }, 402 | "nbformat": 4, 403 | "nbformat_minor": 4 404 | } 405 | -------------------------------------------------------------------------------- /NumPy-calculation.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# NumPy配列入門　②計算" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[NumPy配列入門　②計算【研究で使うPython #52】](https://youtu.be/QTgx7QcVs3M)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "name": "stdout", 35 | "output_type": "stream", 36 | "text": [ 37 | "[3 4 5 6]\n" 38 | ] 39 | } 40 | ], 41 | "source": [ 42 | "a = np.array([1,2,3,4])\n", 43 | "print(a+2)" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 3, 49 | "metadata": {}, 50 | "outputs": [ 51 | { 52 | "name": "stdout", 53 | "output_type": "stream", 54 | "text": [ 55 | "[0 1 2 3]\n" 56 | ] 57 | } 58 | ], 59 | "source": [ 60 | "print(a-1)" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 4, 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "name": "stdout", 70 | "output_type": "stream", 71 | "text": [ 72 | "[ 3 6 9 12]\n" 73 | ] 74 | } 75 | ], 76 | "source": [ 77 | "print(a*3)" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 5, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "name": "stdout", 87 | "output_type": "stream", 88 | "text": [ 89 | "[0.5 1. 1.5 2. ]\n" 90 | ] 91 | } 92 | ], 93 | "source": [ 94 | "print(a/2)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 6, 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "name": "stdout", 104 | "output_type": "stream", 105 | "text": [ 106 | "[4 4 4 4]\n" 107 | ] 108 | } 109 | ], 110 | "source": [ 111 | "b = np.array([3,2,1,0])\n", 112 | "print(a+b)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 7, 118 | "metadata": {}, 119 | "outputs": [ 120 | { 121 | "name": "stdout", 122 | "output_type": "stream", 123 | "text": [ 124 | "[ 0.84147098 0.90929743 0.14112001 -0.7568025 ]\n", 125 | "[ 0.54030231 -0.41614684 -0.9899925 -0.65364362]\n" 126 | ] 127 | } 128 | ], 129 | "source": [ 130 | "print(np.sin(a))\n", 131 | "print(np.cos(a))" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "## 線形代数" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "### 行列の積" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 8, 151 | "metadata": {}, 152 | "outputs": [ 153 | { 154 | "name": "stdout", 155 | "output_type": "stream", 156 | "text": [ 157 | "[[1 2]\n", 158 | " [3 4]]\n", 159 | "[[2 2]\n", 160 | " [2 2]]\n", 161 | "[[ 6 6]\n", 162 | " [14 14]]\n" 163 | ] 164 | } 165 | ], 166 | "source": [ 167 | "a = np.array([[1,2],[3,4]])\n", 168 | "b = np.full((2,2), 2)\n", 169 | "print(a)\n", 170 | "print(b)\n", 171 | "\n", 172 | "print(np.dot(a, b))" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "### 逆行列" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 9, 185 | "metadata": {}, 186 | "outputs": [ 187 | { 188 | "name": "stdout", 189 | "output_type": "stream", 190 | "text": [ 191 | "[[-2. 1. ]\n", 192 | " [ 1.5 -0.5]]\n" 193 | ] 194 | } 195 | ], 196 | "source": [ 197 | "a = np.array([[1,2],[3,4]])\n", 198 | "print(np.linalg.inv(a))" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "### 行列式" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 10, 211 | "metadata": { 212 | "scrolled": true 213 | }, 214 | "outputs": [ 215 | { 216 | "name": "stdout", 217 | "output_type": "stream", 218 | "text": [ 219 | "[[0 1]\n", 220 | " [2 3]]\n", 221 | "-2.0\n", 222 | "[[1. 0. 0.]\n", 223 | " [0. 1. 0.]\n", 224 | " [0. 0. 1.]]\n", 225 | "1.0\n" 226 | ] 227 | } 228 | ], 229 | "source": [ 230 | "a = np.array([[0, 1], [2, 3]])\n", 231 | "print(a)\n", 232 | "print(np.linalg.det(a))\n", 233 | "\n", 234 | "b = np.identity(3)\n", 235 | "print(b)\n", 236 | "print(np.linalg.det(b))" 237 | ] 238 | }, 239 | { 240 | "cell_type": "markdown", 241 | "metadata": {}, 242 | "source": [ 243 | "### 固有値と固有ベクトル" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": 11, 249 | "metadata": {}, 250 | "outputs": [ 251 | { 252 | "name": "stdout", 253 | "output_type": "stream", 254 | "text": [ 255 | "[2. 5.]\n", 256 | "[[-0.70710678 -0.4472136 ]\n", 257 | " [ 0.70710678 -0.89442719]]\n" 258 | ] 259 | } 260 | ], 261 | "source": [ 262 | "a = np.array([[3, 1],[2, 4]])\n", 263 | "\n", 264 | "# a_eig[0]に固有値、a_eig[1]に固有ベクトルが格納される\n", 265 | "a_eig = np.linalg.eig(a)\n", 266 | "\n", 267 | "# 固有値を表示\n", 268 | "print(a_eig[0])\n", 269 | "\n", 270 | "# 固有ベクトルを表示\n", 271 | "print(a_eig[1])" 272 | ] 273 | }, 274 | { 275 | "cell_type": "markdown", 276 | "metadata": {}, 277 | "source": [ 278 | "## 基本統計量" 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": 12, 284 | "metadata": {}, 285 | "outputs": [], 286 | "source": [ 287 | "a = a = np.array([[1,2,3],[4,5,6]])" 288 | ] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": 13, 293 | "metadata": {}, 294 | "outputs": [ 295 | { 296 | "name": "stdout", 297 | "output_type": "stream", 298 | "text": [ 299 | "3.5\n", 300 | "1\n", 301 | "6\n", 302 | "21\n", 303 | "1.707825127659933\n", 304 | "2.9166666666666665\n" 305 | ] 306 | } 307 | ], 308 | "source": [ 309 | "print(np.mean(a)) # 平均\n", 310 | "print(np.min(a)) # 最小値\n", 311 | "print(np.max(a)) # 最大値\n", 312 | "print(np.sum(a)) # 合計\n", 313 | "print(np.std(a)) # 標準偏差\n", 314 | "print(np.var(a)) # 分散" 315 | ] 316 | }, 317 | { 318 | "cell_type": "markdown", 319 | "metadata": {}, 320 | "source": [ 321 | "## その他" 322 | ] 323 | }, 324 | { 325 | "cell_type": "markdown", 326 | "metadata": {}, 327 | "source": [ 328 | "### ファイル読み込み" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 14, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "name": "stdout", 338 | "output_type": "stream", 339 | "text": [ 340 | "[ 1. 10. 20. 30. 40. 50.]\n" 341 | ] 342 | } 343 | ], 344 | "source": [ 345 | "f = np.genfromtxt('data.txt', delimiter=',')\n", 346 | "print(f)" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": 15, 352 | "metadata": {}, 353 | "outputs": [ 354 | { 355 | "name": "stdout", 356 | "output_type": "stream", 357 | "text": [ 358 | "[False False False True True True]\n" 359 | ] 360 | } 361 | ], 362 | "source": [ 363 | "print(f > 20)" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": 16, 369 | "metadata": {}, 370 | "outputs": [ 371 | { 372 | "name": "stdout", 373 | "output_type": "stream", 374 | "text": [ 375 | "[30. 40. 50.]\n" 376 | ] 377 | } 378 | ], 379 | "source": [ 380 | "print(f[f>20])" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": null, 386 | "metadata": {}, 387 | "outputs": [], 388 | "source": [] 389 | } 390 | ], 391 | "metadata": { 392 | "kernelspec": { 393 | "display_name": "Python 3", 394 | "language": "python", 395 | "name": "python3" 396 | }, 397 | "language_info": { 398 | "codemirror_mode": { 399 | "name": "ipython", 400 | "version": 3 401 | }, 402 | "file_extension": ".py", 403 | "mimetype": "text/x-python", 404 | "name": "python", 405 | "nbconvert_exporter": "python", 406 | "pygments_lexer": "ipython3", 407 | "version": "3.7.6" 408 | } 409 | }, 410 | "nbformat": 4, 411 | "nbformat_minor": 4 412 | } 413 | -------------------------------------------------------------------------------- /OOP-conception.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# オブジェクト指向の考え方" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[オブジェクト指向プログラミングの考え方【研究で使うPython #31】](https://youtu.be/EJeAfe6Zwgw)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## 手続き型" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "outputs": [ 31 | { 32 | "name": "stdout", 33 | "output_type": "stream", 34 | "text": [ 35 | "0\n", 36 | "1\n", 37 | "2\n", 38 | "1\n", 39 | "2\n", 40 | "3\n", 41 | "2\n", 42 | "1\n", 43 | "0\n", 44 | "-1\n", 45 | "0\n" 46 | ] 47 | } 48 | ], 49 | "source": [ 50 | "import numpy.random as np\n", 51 | "\n", 52 | "x = 0\n", 53 | "print(x)\n", 54 | "\n", 55 | "for i in range(10):\n", 56 | " r = np.randint(2)*2 - 1 # -1 or +1の乱数\n", 57 | " x += r\n", 58 | " print(x)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "## オブジェクト指向" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 2, 71 | "metadata": {}, 72 | "outputs": [ 73 | { 74 | "name": "stdout", 75 | "output_type": "stream", 76 | "text": [ 77 | "0\n", 78 | "-1\n", 79 | "0\n", 80 | "-1\n", 81 | "-2\n", 82 | "-1\n", 83 | "0\n", 84 | "1\n", 85 | "2\n", 86 | "1\n", 87 | "0\n" 88 | ] 89 | } 90 | ], 91 | "source": [ 92 | "class Agent:\n", 93 | " def __init__(self):\n", 94 | " self.x = 0\n", 95 | " \n", 96 | " def move(self, r):\n", 97 | " self.x += r\n", 98 | " \n", 99 | "# オブジェクト生成\n", 100 | "agent = Agent()\n", 101 | "print(agent.x)\n", 102 | "\n", 103 | "for i in range(10):\n", 104 | " r = np.randint(2)*2 - 1 # -1 or +1の乱数\n", 105 | " agent.move(r)\n", 106 | " print(agent.x)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [] 115 | } 116 | ], 117 | "metadata": { 118 | "kernelspec": { 119 | "display_name": "Python 3", 120 | "language": "python", 121 | "name": "python3" 122 | }, 123 | "language_info": { 124 | "codemirror_mode": { 125 | "name": "ipython", 126 | "version": 3 127 | }, 128 | "file_extension": ".py", 129 | "mimetype": "text/x-python", 130 | "name": "python", 131 | "nbconvert_exporter": "python", 132 | "pygments_lexer": "ipython3", 133 | "version": "3.7.6" 134 | } 135 | }, 136 | "nbformat": 4, 137 | "nbformat_minor": 4 138 | } 139 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # youtube_python 2 | 研究者ゲンキの[YouTubeチャンネル](https://www.youtube.com/channel/UC0UnEjW_QUMHqjvQXYJ3WhQ)で作成したPythonのプログラムファイル（Jupyter Notebook形式）です． 3 | -------------------------------------------------------------------------------- /SIR-model.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# SIRモデルのシミュレーション" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[【研究で使うPython】#20 SIRモデルによる感染症伝播のシミュレーション](https://youtu.be/7oyd02Li9ks)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "$$\n", 24 | "\\begin{cases}\n", 25 | "\\frac{dS(t)}{dt} = -\\beta S(t) I(t)\\\\\n", 26 | "\\frac{dI(t)}{dt} = \\beta S(t) I(t) - \\gamma I(t)\\\\\n", 27 | "\\frac{dR(t)}{dt} = \\gamma I(t)\n", 28 | "\\end{cases}\n", 29 | "$$" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 5, 35 | "metadata": {}, 36 | "outputs": [ 37 | { 38 | "data": { 39 | "text/plain": [ 40 | "" 41 | ] 42 | }, 43 | "execution_count": 5, 44 | "metadata": {}, 45 | "output_type": "execute_result" 46 | }, 47 | { 48 | "data": { 49 | "image/png": "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\n", 50 | "text/plain": [ 51 | "
" 52 | ] 53 | }, 54 | "metadata": { 55 | "needs_background": "light" 56 | }, 57 | "output_type": "display_data" 58 | } 59 | ], 60 | "source": [ 61 | "%matplotlib inline\n", 62 | "import matplotlib.pyplot as plt\n", 63 | "\n", 64 | "# SIRモデル\n", 65 | "beta = 0.002 # 感染率\n", 66 | "gamma = 1 # 回復率\n", 67 | "S0 = 1000\n", 68 | "I0 = 1\n", 69 | "R0 = 0\n", 70 | "\n", 71 | "dt = 0.0001 # 刻み幅\n", 72 | "t = 0\n", 73 | "S = S0\n", 74 | "I = I0\n", 75 | "R = R0\n", 76 | "SList = [S0]\n", 77 | "IList = [I0]\n", 78 | "RList = [R0]\n", 79 | "tList = [t]\n", 80 | "for i in range(300000):\n", 81 | " t = dt*(i+1)\n", 82 | " S_ = S + dt*(-beta*S*I)\n", 83 | " I_ = I + dt*(beta*S*I-gamma*I)\n", 84 | " R_ = R + dt*(gamma*I)\n", 85 | " S = S_\n", 86 | " I = I_\n", 87 | " R = R_\n", 88 | " tList.append(t)\n", 89 | " SList.append(S)\n", 90 | " IList.append(I)\n", 91 | " RList.append(R)\n", 92 | "plt.plot(tList, SList, color='green', label='S')\n", 93 | "plt.plot(tList, IList, color='red', label='I')\n", 94 | "plt.plot(tList, RList, color='blue', label='R')\n", 95 | "plt.legend()" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": null, 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [] 104 | } 105 | ], 106 | "metadata": { 107 | "kernelspec": { 108 | "display_name": "Python 3", 109 | "language": "python", 110 | "name": "python3" 111 | }, 112 | "language_info": { 113 | "codemirror_mode": { 114 | "name": "ipython", 115 | "version": 3 116 | }, 117 | "file_extension": ".py", 118 | "mimetype": "text/x-python", 119 | "name": "python", 120 | "nbconvert_exporter": "python", 121 | "pygments_lexer": "ipython3", 122 | "version": "3.7.6" 123 | } 124 | }, 125 | "nbformat": 4, 126 | "nbformat_minor": 4 127 | } 128 | -------------------------------------------------------------------------------- /SymPy-basic.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# SymPy入門" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[理系学生のためのSymPy入門編【研究で使うPython #69】](https://youtu.be/cjCv9JCqHag)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## 必要モジュールをインポート" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "import sympy as sp" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## 記号の定義" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 2, 45 | "metadata": {}, 46 | "outputs": [ 47 | { 48 | "data": { 49 | "text/latex": [ 50 | "$\\displaystyle x$" 51 | ], 52 | "text/plain": [ 53 | "x" 54 | ] 55 | }, 56 | "execution_count": 2, 57 | "metadata": {}, 58 | "output_type": "execute_result" 59 | } 60 | ], 61 | "source": [ 62 | "# 1つの記号の導入\n", 63 | "x = sp.Symbol('x')\n", 64 | "x" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 3, 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "data": { 74 | "text/latex": [ 75 | "$\\displaystyle x^{2} + y^{2}$" 76 | ], 77 | "text/plain": [ 78 | "x**2 + y**2" 79 | ] 80 | }, 81 | "execution_count": 3, 82 | "metadata": {}, 83 | "output_type": "execute_result" 84 | } 85 | ], 86 | "source": [ 87 | "# 複数の記号の導入\n", 88 | "x, y, z = sp.symbols('x y z')\n", 89 | "x**2 + y**2" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 4, 95 | "metadata": {}, 96 | "outputs": [ 97 | { 98 | "data": { 99 | "text/latex": [ 100 | "$\\displaystyle x \\left(x + y + z\\right)$" 101 | ], 102 | "text/plain": [ 103 | "x*(x + y + z)" 104 | ] 105 | }, 106 | "metadata": {}, 107 | "output_type": "display_data" 108 | }, 109 | { 110 | "data": { 111 | "text/latex": [ 112 | "$\\displaystyle a^{2} \\left(b + c\\right)$" 113 | ], 114 | "text/plain": [ 115 | "a**2*(b + c)" 116 | ] 117 | }, 118 | "metadata": {}, 119 | "output_type": "display_data" 120 | } 121 | ], 122 | "source": [ 123 | "expr1 = x*(x+y+z)\n", 124 | "#expr1\n", 125 | "display(expr1)\n", 126 | "\n", 127 | "# 複数の記号の導入（別バージョン）\n", 128 | "sp.var('a b c')\n", 129 | "expr2 = a*(b+c)*a\n", 130 | "#expr2\n", 131 | "display(expr2)" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 5, 137 | "metadata": {}, 138 | "outputs": [ 139 | { 140 | "data": { 141 | "text/latex": [ 142 | "$\\displaystyle \\sin{\\left(x \\right)} + \\cos{\\left(y \\right)}$" 143 | ], 144 | "text/plain": [ 145 | "sin(x) + cos(y)" 146 | ] 147 | }, 148 | "execution_count": 5, 149 | "metadata": {}, 150 | "output_type": "execute_result" 151 | } 152 | ], 153 | "source": [ 154 | "sp.sin(x)+sp.cos(y)" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "sp.の後に[tab]キーでSymPyで使える関数が出てくる" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 6, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [ 170 | "#sp." 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "新しい変数に式を保存" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 7, 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "data": { 187 | "text/latex": [ 188 | "$\\displaystyle x^{2} + 5 x + 2$" 189 | ], 190 | "text/plain": [ 191 | "x**2 + 5*x + 2" 192 | ] 193 | }, 194 | "metadata": {}, 195 | "output_type": "display_data" 196 | }, 197 | { 198 | "data": { 199 | "text/latex": [ 200 | "$\\displaystyle \\left(x^{2} + 5 x + 2\\right)^{2}$" 201 | ], 202 | "text/plain": [ 203 | "(x**2 + 5*x + 2)**2" 204 | ] 205 | }, 206 | "metadata": {}, 207 | "output_type": "display_data" 208 | } 209 | ], 210 | "source": [ 211 | "y = x**2 + 5*x + 2\n", 212 | "display(y)\n", 213 | "z = y**2\n", 214 | "display(z)" 215 | ] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": [ 221 | "## 展開と因数分解" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": 8, 227 | "metadata": { 228 | "scrolled": true 229 | }, 230 | "outputs": [ 231 | { 232 | "data": { 233 | "text/latex": [ 234 | "$\\displaystyle x^{3} + 3 x^{2} y + 3 x y^{2} + y^{3}$" 235 | ], 236 | "text/plain": [ 237 | "x**3 + 3*x**2*y + 3*x*y**2 + y**3" 238 | ] 239 | }, 240 | "metadata": {}, 241 | "output_type": "display_data" 242 | }, 243 | { 244 | "data": { 245 | "text/latex": [ 246 | "$\\displaystyle \\left(x + y\\right)^{3}$" 247 | ], 248 | "text/plain": [ 249 | "(x + y)**3" 250 | ] 251 | }, 252 | "metadata": {}, 253 | "output_type": "display_data" 254 | }, 255 | { 256 | "data": { 257 | "text/latex": [ 258 | "$\\displaystyle x^{3} + 3 x^{2} y + 3 x y^{2} + y^{3}$" 259 | ], 260 | "text/plain": [ 261 | "x**3 + 3*x**2*y + 3*x*y**2 + y**3" 262 | ] 263 | }, 264 | "metadata": {}, 265 | "output_type": "display_data" 266 | } 267 | ], 268 | "source": [ 269 | "x, y, z = sp.symbols('x y z')\n", 270 | "expr = x**3 + 3*x**2*y + 3*x*y**2 + y**3\n", 271 | "display(expr)\n", 272 | "\n", 273 | "expr1 = sp.factor(expr)\n", 274 | "display(expr1)\n", 275 | "\n", 276 | "expr2 = sp.expand(expr1)\n", 277 | "display(expr2)" 278 | ] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": {}, 283 | "source": [ 284 | "## 簡単化" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 9, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "data": { 294 | "text/latex": [ 295 | "$\\displaystyle \\frac{x y + x}{x}$" 296 | ], 297 | "text/plain": [ 298 | "(x*y + x)/x" 299 | ] 300 | }, 301 | "metadata": {}, 302 | "output_type": "display_data" 303 | }, 304 | { 305 | "data": { 306 | "text/latex": [ 307 | "$\\displaystyle y + 1$" 308 | ], 309 | "text/plain": [ 310 | "y + 1" 311 | ] 312 | }, 313 | "metadata": {}, 314 | "output_type": "display_data" 315 | } 316 | ], 317 | "source": [ 318 | "expr = (x+x*y)/x\n", 319 | "display(expr)\n", 320 | "\n", 321 | "display(sp.simplify(expr))" 322 | ] 323 | }, 324 | { 325 | "cell_type": "markdown", 326 | "metadata": {}, 327 | "source": [ 328 | "## 代入" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 10, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "data": { 338 | "text/latex": [ 339 | "$\\displaystyle x^{2} - 4 x + 4$" 340 | ], 341 | "text/plain": [ 342 | "x**2 - 4*x + 4" 343 | ] 344 | }, 345 | "metadata": {}, 346 | "output_type": "display_data" 347 | }, 348 | { 349 | "data": { 350 | "text/latex": [ 351 | "$\\displaystyle \\left(x - 2\\right)^{2}$" 352 | ], 353 | "text/plain": [ 354 | "(x - 2)**2" 355 | ] 356 | }, 357 | "metadata": {}, 358 | "output_type": "display_data" 359 | }, 360 | { 361 | "data": { 362 | "text/latex": [ 363 | "$\\displaystyle 0$" 364 | ], 365 | "text/plain": [ 366 | "0" 367 | ] 368 | }, 369 | "metadata": {}, 370 | "output_type": "display_data" 371 | }, 372 | { 373 | "data": { 374 | "text/latex": [ 375 | "$\\displaystyle a^{2} - 4 a + 4$" 376 | ], 377 | "text/plain": [ 378 | "a**2 - 4*a + 4" 379 | ] 380 | }, 381 | "metadata": {}, 382 | "output_type": "display_data" 383 | } 384 | ], 385 | "source": [ 386 | "x, a = sp.symbols('x a')\n", 387 | "expr = x**2 - 4*x + 4\n", 388 | "display(expr)\n", 389 | "display(sp.factor(expr))\n", 390 | "\n", 391 | "display(expr.subs([(x, 2)]))\n", 392 | "display(expr.subs([(x, a)]))" 393 | ] 394 | }, 395 | { 396 | "cell_type": "markdown", 397 | "metadata": {}, 398 | "source": [ 399 | "## 微分" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": 11, 405 | "metadata": {}, 406 | "outputs": [ 407 | { 408 | "data": { 409 | "text/latex": [ 410 | "$\\displaystyle 2 x$" 411 | ], 412 | "text/plain": [ 413 | "2*x" 414 | ] 415 | }, 416 | "metadata": {}, 417 | "output_type": "display_data" 418 | }, 419 | { 420 | "data": { 421 | "text/latex": [ 422 | "$\\displaystyle \\cos{\\left(x \\right)}$" 423 | ], 424 | "text/plain": [ 425 | "cos(x)" 426 | ] 427 | }, 428 | "metadata": {}, 429 | "output_type": "display_data" 430 | } 431 | ], 432 | "source": [ 433 | "x = sp.Symbol('x')\n", 434 | "display(sp.diff(x**2, x))\n", 435 | "display(sp.diff(sp.sin(x), x))" 436 | ] 437 | }, 438 | { 439 | "cell_type": "markdown", 440 | "metadata": {}, 441 | "source": [ 442 | "## 方程式を解く" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": 12, 448 | "metadata": {}, 449 | "outputs": [ 450 | { 451 | "data": { 452 | "text/latex": [ 453 | "$\\displaystyle x^{2} - 3 x + 2$" 454 | ], 455 | "text/plain": [ 456 | "x**2 - 3*x + 2" 457 | ] 458 | }, 459 | "metadata": {}, 460 | "output_type": "display_data" 461 | }, 462 | { 463 | "data": { 464 | "text/latex": [ 465 | "$\\displaystyle \\left(x - 2\\right) \\left(x - 1\\right)$" 466 | ], 467 | "text/plain": [ 468 | "(x - 2)*(x - 1)" 469 | ] 470 | }, 471 | "metadata": {}, 472 | "output_type": "display_data" 473 | }, 474 | { 475 | "data": { 476 | "text/plain": [ 477 | "[1, 2]" 478 | ] 479 | }, 480 | "metadata": {}, 481 | "output_type": "display_data" 482 | } 483 | ], 484 | "source": [ 485 | "x = sp.Symbol('x')\n", 486 | "f = x**2 - 3*x +2\n", 487 | "display(f)\n", 488 | "display(sp.factor(f))\n", 489 | "\n", 490 | "# f(x)=0となるxの値を見つけている\n", 491 | "display(sp.solve(f, x))" 492 | ] 493 | }, 494 | { 495 | "cell_type": "markdown", 496 | "metadata": {}, 497 | "source": [ 498 | "以下の連立方程式を解く\n", 499 | "$$\n", 500 | "\\begin{cases}\n", 501 | "2x + 3y = 6 \\\\\n", 502 | "3x + 2y = 12\n", 503 | "\\end{cases}\n", 504 | "$$" 505 | ] 506 | }, 507 | { 508 | "cell_type": "code", 509 | "execution_count": 13, 510 | "metadata": {}, 511 | "outputs": [ 512 | { 513 | "data": { 514 | "text/plain": [ 515 | "{x: 24/5, y: -6/5}" 516 | ] 517 | }, 518 | "metadata": {}, 519 | "output_type": "display_data" 520 | } 521 | ], 522 | "source": [ 523 | "x, y = sp.symbols('x y')\n", 524 | "# 右辺を移行して0にしてからsolve()関数に渡す\n", 525 | "expr1 = 2*x + 3*y - 6\n", 526 | "expr2 = 3*x + 2*y -12\n", 527 | "# 辞書形式で出力される\n", 528 | "display(sp.solve((expr1, expr2)))" 529 | ] 530 | } 531 | ], 532 | "metadata": { 533 | "kernelspec": { 534 | "display_name": "Python 3", 535 | "language": "python", 536 | "name": "python3" 537 | }, 538 | "language_info": { 539 | "codemirror_mode": { 540 | "name": "ipython", 541 | "version": 3 542 | }, 543 | "file_extension": ".py", 544 | "mimetype": "text/x-python", 545 | "name": "python", 546 | "nbconvert_exporter": "python", 547 | "pygments_lexer": "ipython3", 548 | "version": "3.7.6" 549 | } 550 | }, 551 | "nbformat": 4, 552 | "nbformat_minor": 4 553 | } 554 | -------------------------------------------------------------------------------- /SymPyLinearAlgebra.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# SymPyによる線形代数" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "対応する動画：[理系学生のためのSymPyによる線形代数【研究で使うPython #70】](https://youtu.be/qnDKnIKPQGI)\n", 15 | "\n", 16 | "動画のプレイリスト：[研究で使うPython](https://www.youtube.com/playlist?list=PLw5AEs-T7pLHxLaNvGD9tnhrDxAgH-QIw)" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## ライブラリのインポート" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "import sympy as sp" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## 行列の生成" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 2, 45 | "metadata": {}, 46 | "outputs": [ 47 | { 48 | "data": { 49 | "text/latex": [ 50 | "$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\\\5 & 6\\end{matrix}\\right]$" 51 | ], 52 | "text/plain": [ 53 | "Matrix([\n", 54 | "[1, 2],\n", 55 | "[3, 4],\n", 56 | "[5, 6]])" 57 | ] 58 | }, 59 | "execution_count": 2, 60 | "metadata": {}, 61 | "output_type": "execute_result" 62 | } 63 | ], 64 | "source": [ 65 | "sp.Matrix([[1, 2], [3, 4], [5, 6]])" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 3, 71 | "metadata": {}, 72 | "outputs": [ 73 | { 74 | "data": { 75 | "text/latex": [ 76 | "$\\displaystyle \\left[\\begin{matrix}a & b\\\\c & d\\\\e & f\\end{matrix}\\right]$" 77 | ], 78 | "text/plain": [ 79 | "Matrix([\n", 80 | "[a, b],\n", 81 | "[c, d],\n", 82 | "[e, f]])" 83 | ] 84 | }, 85 | "execution_count": 3, 86 | "metadata": {}, 87 | "output_type": "execute_result" 88 | } 89 | ], 90 | "source": [ 91 | "a, b, c, d, e, f = sp.symbols('a b c d e f')\n", 92 | "sp.Matrix([[a, b], [c, d], [e, f]])" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 4, 98 | "metadata": {}, 99 | "outputs": [ 100 | { 101 | "data": { 102 | "text/latex": [ 103 | "$\\displaystyle \\left[\\begin{matrix}1 & b\\\\c & d\\\\e & f\\end{matrix}\\right]$" 104 | ], 105 | "text/plain": [ 106 | "Matrix([\n", 107 | "[1, b],\n", 108 | "[c, d],\n", 109 | "[e, f]])" 110 | ] 111 | }, 112 | "execution_count": 4, 113 | "metadata": {}, 114 | "output_type": "execute_result" 115 | } 116 | ], 117 | "source": [ 118 | "sp.Matrix([[a,b], [c, d], [e, f]]).subs(a, 1)" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 5, 124 | "metadata": {}, 125 | "outputs": [ 126 | { 127 | "data": { 128 | "text/latex": [ 129 | "$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\\\5 & 6\\end{matrix}\\right]$" 130 | ], 131 | "text/plain": [ 132 | "Matrix([\n", 133 | "[1, 2],\n", 134 | "[3, 4],\n", 135 | "[5, 6]])" 136 | ] 137 | }, 138 | "execution_count": 5, 139 | "metadata": {}, 140 | "output_type": "execute_result" 141 | } 142 | ], 143 | "source": [ 144 | "sp.Matrix(3, 2, [1, 2, 3, 4, 5, 6])" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 6, 150 | "metadata": {}, 151 | "outputs": [ 152 | { 153 | "data": { 154 | "text/latex": [ 155 | "$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\4 & 5 & 6\\end{matrix}\\right]$" 156 | ], 157 | "text/plain": [ 158 | "Matrix([\n", 159 | "[1, 2, 3],\n", 160 | "[4, 5, 6]])" 161 | ] 162 | }, 163 | "execution_count": 6, 164 | "metadata": {}, 165 | "output_type": "execute_result" 166 | } 167 | ], 168 | "source": [ 169 | "sp.Matrix(2, 3, [1, 2, 3, 4, 5, 6])" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": {}, 175 | "source": [ 176 | "### 列ベクトル（$n\\times1$行列）" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 7, 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "data": { 186 | "text/latex": [ 187 | "$\\displaystyle \\left[\\begin{matrix}1\\\\2\\\\3\\\\4\\end{matrix}\\right]$" 188 | ], 189 | "text/plain": [ 190 | "Matrix([\n", 191 | "[1],\n", 192 | "[2],\n", 193 | "[3],\n", 194 | "[4]])" 195 | ] 196 | }, 197 | "execution_count": 7, 198 | "metadata": {}, 199 | "output_type": "execute_result" 200 | } 201 | ], 202 | "source": [ 203 | "sp.Matrix([1,2,3,4])" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": {}, 209 | "source": [ 210 | "### 行ベクトル（$1 \\times n$行列）" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 8, 216 | "metadata": {}, 217 | "outputs": [ 218 | { 219 | "data": { 220 | "text/latex": [ 221 | "$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3 & 4\\end{matrix}\\right]$" 222 | ], 223 | "text/plain": [ 224 | "Matrix([[1, 2, 3, 4]])" 225 | ] 226 | }, 227 | "execution_count": 8, 228 | "metadata": {}, 229 | "output_type": "execute_result" 230 | } 231 | ], 232 | "source": [ 233 | "sp.Matrix(1, 4, [1,2,3,4])" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": 9, 239 | "metadata": {}, 240 | "outputs": [ 241 | { 242 | "data": { 243 | "text/latex": [ 244 | "$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3 & 4\\end{matrix}\\right]$" 245 | ], 246 | "text/plain": [ 247 | "Matrix([[1, 2, 3, 4]])" 248 | ] 249 | }, 250 | "execution_count": 9, 251 | "metadata": {}, 252 | "output_type": "execute_result" 253 | } 254 | ], 255 | "source": [ 256 | "sp.Matrix([[1,2,3,4]])" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "### 転置" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 10, 269 | "metadata": {}, 270 | "outputs": [ 271 | { 272 | "data": { 273 | "text/latex": [ 274 | "$\\displaystyle \\left[\\begin{matrix}1\\\\2\\\\3\\\\4\\end{matrix}\\right]$" 275 | ], 276 | "text/plain": [ 277 | "Matrix([\n", 278 | "[1],\n", 279 | "[2],\n", 280 | "[3],\n", 281 | "[4]])" 282 | ] 283 | }, 284 | "execution_count": 10, 285 | "metadata": {}, 286 | "output_type": "execute_result" 287 | } 288 | ], 289 | "source": [ 290 | "sp.Matrix([[1,2,3,4]]).T\n", 291 | "# sp.Matrix([[1,2,3,4]]).transpose()" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "## 行列の変数への格納" 299 | ] 300 | }, 301 | { 302 | "cell_type": "markdown", 303 | "metadata": {}, 304 | "source": [ 305 | "$$\n", 306 | " A =\n", 307 | " \\left(\\begin{array}{cc}\n", 308 | " 1 & 2 \\\\\n", 309 | " 3 & 4\\\\\n", 310 | " \\end{array}\\right), \\quad\n", 311 | " B =\n", 312 | " \\left(\\begin{array}{cc}\n", 313 | " 5 & 6 \\\\\n", 314 | " 7 & 8 \\\\\n", 315 | " \\end{array}\\right) \\quad\n", 316 | "$$" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": 11, 322 | "metadata": {}, 323 | "outputs": [], 324 | "source": [ 325 | "A = sp.Matrix([[1, 2], [3, 4]])\n", 326 | "B = sp.Matrix([[5, 6], [7, 8]])" 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": 12, 332 | "metadata": {}, 333 | "outputs": [ 334 | { 335 | "data": { 336 | "text/latex": [ 337 | "$\\displaystyle \\left[\\begin{matrix}5 & 6\\\\7 & 8\\end{matrix}\\right]$" 338 | ], 339 | "text/plain": [ 340 | "Matrix([\n", 341 | "[5, 6],\n", 342 | "[7, 8]])" 343 | ] 344 | }, 345 | "execution_count": 12, 346 | "metadata": {}, 347 | "output_type": "execute_result" 348 | } 349 | ], 350 | "source": [ 351 | "A\n", 352 | "B\n", 353 | "#display(A)\n", 354 | "#display(B)" 355 | ] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "## 行列の演算" 362 | ] 363 | }, 364 | { 365 | "cell_type": "markdown", 366 | "metadata": {}, 367 | "source": [ 368 | "$$\n", 369 | " A =\n", 370 | " \\left(\\begin{array}{cc}\n", 371 | " 1 & 2 \\\\\n", 372 | " 3 & 4\\\\\n", 373 | " \\end{array}\\right), \\quad\n", 374 | " B =\n", 375 | " \\left(\\begin{array}{cc}\n", 376 | " 5 & 6 \\\\\n", 377 | " 7 & 8 \\\\\n", 378 | " \\end{array}\\right) \\quad\n", 379 | "$$" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 13, 385 | "metadata": {}, 386 | "outputs": [ 387 | { 388 | "data": { 389 | "text/latex": [ 390 | "$\\displaystyle \\left[\\begin{matrix}6 & 8\\\\10 & 12\\end{matrix}\\right]$" 391 | ], 392 | "text/plain": [ 393 | "Matrix([\n", 394 | "[ 6, 8],\n", 395 | "[10, 12]])" 396 | ] 397 | }, 398 | "execution_count": 13, 399 | "metadata": {}, 400 | "output_type": "execute_result" 401 | } 402 | ], 403 | "source": [ 404 | "A+B" 405 | ] 406 | }, 407 | { 408 | "cell_type": "code", 409 | "execution_count": 14, 410 | "metadata": {}, 411 | "outputs": [ 412 | { 413 | "data": { 414 | "text/latex": [ 415 | "$\\displaystyle \\left[\\begin{matrix}2 & 4\\\\6 & 8\\end{matrix}\\right]$" 416 | ], 417 | "text/plain": [ 418 | "Matrix([\n", 419 | "[2, 4],\n", 420 | "[6, 8]])" 421 | ] 422 | }, 423 | "execution_count": 14, 424 | "metadata": {}, 425 | "output_type": "execute_result" 426 | } 427 | ], 428 | "source": [ 429 | "2 * A" 430 | ] 431 | }, 432 | { 433 | "cell_type": "code", 434 | "execution_count": 15, 435 | "metadata": {}, 436 | "outputs": [ 437 | { 438 | "data": { 439 | "text/latex": [ 440 | "$\\displaystyle \\left[\\begin{matrix}5 k & 6 k\\\\7 k & 8 k\\end{matrix}\\right]$" 441 | ], 442 | "text/plain": [ 443 | "Matrix([\n", 444 | "[5*k, 6*k],\n", 445 | "[7*k, 8*k]])" 446 | ] 447 | }, 448 | "execution_count": 15, 449 | "metadata": {}, 450 | "output_type": "execute_result" 451 | } 452 | ], 453 | "source": [ 454 | "k = sp.Symbol('k')\n", 455 | "k * B" 456 | ] 457 | }, 458 | { 459 | "cell_type": "markdown", 460 | "metadata": {}, 461 | "source": [ 462 | "$$\n", 463 | " A =\n", 464 | " \\left(\\begin{array}{cc}\n", 465 | " a_{11} & a_{12} \\\\\n", 466 | " a_{21} & a_{22}\\\\\n", 467 | " \\end{array}\\right), \\quad\n", 468 | " B =\n", 469 | " \\left(\\begin{array}{cc}\n", 470 | " b_{11} & b_{12} \\\\\n", 471 | " b_{21} & b_{22} \\\\\n", 472 | " \\end{array}\\right) \\quad\n", 473 | "$$\n", 474 | "行列の積$AB$を求める" 475 | ] 476 | }, 477 | { 478 | "cell_type": "code", 479 | "execution_count": 16, 480 | "metadata": {}, 481 | "outputs": [ 482 | { 483 | "data": { 484 | "text/latex": [ 485 | "$\\displaystyle \\left[\\begin{matrix}a_{11} & a_{12}\\\\a_{21} & a_{22}\\end{matrix}\\right]$" 486 | ], 487 | "text/plain": [ 488 | "Matrix([\n", 489 | "[a11, a12],\n", 490 | "[a21, a22]])" 491 | ] 492 | }, 493 | "metadata": {}, 494 | "output_type": "display_data" 495 | }, 496 | { 497 | "data": { 498 | "text/latex": [ 499 | "$\\displaystyle \\left[\\begin{matrix}b_{11} & b_{12}\\\\b_{21} & b_{22}\\end{matrix}\\right]$" 500 | ], 501 | "text/plain": [ 502 | "Matrix([\n", 503 | "[b11, b12],\n", 504 | "[b21, b22]])" 505 | ] 506 | }, 507 | "metadata": {}, 508 | "output_type": "display_data" 509 | }, 510 | { 511 | "data": { 512 | "text/latex": [ 513 | "$\\displaystyle \\left[\\begin{matrix}a_{11} b_{11} + a_{12} b_{21} & a_{11} b_{12} + a_{12} b_{22}\\\\a_{21} b_{11} + a_{22} b_{21} & a_{21} b_{12} + a_{22} b_{22}\\end{matrix}\\right]$" 514 | ], 515 | "text/plain": [ 516 | "Matrix([\n", 517 | "[a11*b11 + a12*b21, a11*b12 + a12*b22],\n", 518 | "[a21*b11 + a22*b21, a21*b12 + a22*b22]])" 519 | ] 520 | }, 521 | "metadata": {}, 522 | "output_type": "display_data" 523 | } 524 | ], 525 | "source": [ 526 | "sp.var('a11, a12, a21, a22, b11, b12, b21, b22')\n", 527 | "A = sp.Matrix([[a11, a12], [a21, a22]])\n", 528 | "display(A)\n", 529 | "B = sp.Matrix([[b11, b12], [b21, b22]])\n", 530 | "display(B)\n", 531 | "\n", 532 | "# 行列の積\n", 533 | "display(A * B)\n", 534 | "# NumPyの場合はdot()関数で求めることに注意" 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": 17, 540 | "metadata": {}, 541 | "outputs": [ 542 | { 543 | "data": { 544 | "text/latex": [ 545 | "$\\displaystyle \\left[\\begin{matrix}19 & 22\\\\43 & 50\\end{matrix}\\right]$" 546 | ], 547 | "text/plain": [ 548 | "Matrix([\n", 549 | "[19, 22],\n", 550 | "[43, 50]])" 551 | ] 552 | }, 553 | "execution_count": 17, 554 | "metadata": {}, 555 | "output_type": "execute_result" 556 | } 557 | ], 558 | "source": [ 559 | "A = sp.Matrix([[1, 2], [3, 4]])\n", 560 | "B = sp.Matrix([[5, 6], [7, 8]])\n", 561 | "A * B" 562 | ] 563 | }, 564 | { 565 | "cell_type": "markdown", 566 | "metadata": {}, 567 | "source": [ 568 | "## 行列式" 569 | ] 570 | }, 571 | { 572 | "cell_type": "markdown", 573 | "metadata": {}, 574 | "source": [ 575 | "$$\n", 576 | " A =\n", 577 | " \\left(\\begin{array}{cc}\n", 578 | " a_{11} & a_{12} \\\\\n", 579 | " a_{21} & a_{22}\\\\\n", 580 | " \\end{array}\\right)\n", 581 | "$$\n", 582 | "の行列式$\\mathrm{det}(A)$を求める" 583 | ] 584 | }, 585 | { 586 | "cell_type": "code", 587 | "execution_count": 18, 588 | "metadata": {}, 589 | "outputs": [ 590 | { 591 | "data": { 592 | "text/latex": [ 593 | "$\\displaystyle a_{11} a_{22} - a_{12} a_{21}$" 594 | ], 595 | "text/plain": [ 596 | "a11*a22 - a12*a21" 597 | ] 598 | }, 599 | "execution_count": 18, 600 | "metadata": {}, 601 | "output_type": "execute_result" 602 | } 603 | ], 604 | "source": [ 605 | "A = sp.Matrix([[a11, a12], [a21, a22]])\n", 606 | "sp.det(A)" 607 | ] 608 | }, 609 | { 610 | "cell_type": "markdown", 611 | "metadata": {}, 612 | "source": [ 613 | "$$\n", 614 | " A =\n", 615 | " \\left(\\begin{array}{cc}\n", 616 | " 1 & 2 \\\\\n", 617 | " 3 & 4\\\\\n", 618 | " \\end{array}\\right)\n", 619 | "$$\n", 620 | "の行列式$\\mathrm{det}(A)$を求める" 621 | ] 622 | }, 623 | { 624 | "cell_type": "code", 625 | "execution_count": 19, 626 | "metadata": {}, 627 | "outputs": [ 628 | { 629 | "data": { 630 | "text/latex": [ 631 | "$\\displaystyle -2$" 632 | ], 633 | "text/plain": [ 634 | "-2" 635 | ] 636 | }, 637 | "execution_count": 19, 638 | "metadata": {}, 639 | "output_type": "execute_result" 640 | } 641 | ], 642 | "source": [ 643 | "A = sp.Matrix([[1, 2], [3, 4]])\n", 644 | "sp.det(A)" 645 | ] 646 | }, 647 | { 648 | "cell_type": "markdown", 649 | "metadata": {}, 650 | "source": [ 651 | "## 逆行列" 652 | ] 653 | }, 654 | { 655 | "cell_type": "markdown", 656 | "metadata": {}, 657 | "source": [ 658 | "$$\n", 659 | " A =\n", 660 | " \\left(\\begin{array}{cc}\n", 661 | " a_{11} & a_{12} \\\\\n", 662 | " a_{21} & a_{22}\\\\\n", 663 | " \\end{array}\\right)\n", 664 | "$$\n", 665 | "の逆行列$A^{-1}$を求める" 666 | ] 667 | }, 668 | { 669 | "cell_type": "code", 670 | "execution_count": 20, 671 | "metadata": {}, 672 | "outputs": [ 673 | { 674 | "data": { 675 | "text/latex": [ 676 | "$\\displaystyle \\left[\\begin{matrix}\\frac{a_{22}}{a_{11} a_{22} - a_{12} a_{21}} & - \\frac{a_{12}}{a_{11} a_{22} - a_{12} a_{21}}\\\\- \\frac{a_{21}}{a_{11} a_{22} - a_{12} a_{21}} & \\frac{a_{11}}{a_{11} a_{22} - a_{12} a_{21}}\\end{matrix}\\right]$" 677 | ], 678 | "text/plain": [ 679 | "Matrix([\n", 680 | "[ a22/(a11*a22 - a12*a21), -a12/(a11*a22 - a12*a21)],\n", 681 | "[-a21/(a11*a22 - a12*a21), a11/(a11*a22 - a12*a21)]])" 682 | ] 683 | }, 684 | "execution_count": 20, 685 | "metadata": {}, 686 | "output_type": "execute_result" 687 | } 688 | ], 689 | "source": [ 690 | "A = sp.Matrix([[a11, a12], [a21, a22]])\n", 691 | "A.inv()" 692 | ] 693 | }, 694 | { 695 | "cell_type": "markdown", 696 | "metadata": {}, 697 | "source": [ 698 | "$$\n", 699 | " A =\n", 700 | " \\left(\\begin{array}{cc}\n", 701 | " 1 & 2 \\\\\n", 702 | " 3 & 4\\\\\n", 703 | " \\end{array}\\right)\n", 704 | "$$\n", 705 | "の逆行列$A^{-1}$を求める" 706 | ] 707 | }, 708 | { 709 | "cell_type": "code", 710 | "execution_count": 21, 711 | "metadata": {}, 712 | "outputs": [ 713 | { 714 | "data": { 715 | "text/latex": [ 716 | "$\\displaystyle \\left[\\begin{matrix}-2 & 1\\\\\\frac{3}{2} & - \\frac{1}{2}\\end{matrix}\\right]$" 717 | ], 718 | "text/plain": [ 719 | "Matrix([\n", 720 | "[ -2, 1],\n", 721 | "[3/2, -1/2]])" 722 | ] 723 | }, 724 | "execution_count": 21, 725 | "metadata": {}, 726 | "output_type": "execute_result" 727 | } 728 | ], 729 | "source": [ 730 | "A = sp.Matrix([[1, 2], [3, 4]])\n", 731 | "A.inv()" 732 | ] 733 | }, 734 | { 735 | "cell_type": "markdown", 736 | "metadata": {}, 737 | "source": [ 738 | "## 固有値と固有ベクトル" 739 | ] 740 | }, 741 | { 742 | "cell_type": "markdown", 743 | "metadata": {}, 744 | "source": [ 745 | "$$\n", 746 | " A =\n", 747 | " \\left(\\begin{array}{cc}\n", 748 | " 3 & 1 \\\\\n", 749 | " 2 & 4\\\\\n", 750 | " \\end{array}\\right)\n", 751 | "$$\n", 752 | "の固有値と固有ベクトルを求める" 753 | ] 754 | }, 755 | { 756 | "cell_type": "code", 757 | "execution_count": 22, 758 | "metadata": {}, 759 | "outputs": [ 760 | { 761 | "data": { 762 | "text/plain": [ 763 | "{5: 1, 2: 1}" 764 | ] 765 | }, 766 | "metadata": {}, 767 | "output_type": "display_data" 768 | }, 769 | { 770 | "data": { 771 | "text/plain": [ 772 | "[(2,\n", 773 | " 1,\n", 774 | " [Matrix([\n", 775 | " [-1],\n", 776 | " [ 1]])]),\n", 777 | " (5,\n", 778 | " 1,\n", 779 | " [Matrix([\n", 780 | " [1/2],\n", 781 | " [ 1]])])]" 782 | ] 783 | }, 784 | "metadata": {}, 785 | "output_type": "display_data" 786 | } 787 | ], 788 | "source": [ 789 | "A = sp.Matrix([[3, 1], [2, 4]])\n", 790 | "display(A.eigenvals())\n", 791 | "display(A.eigenvects())" 792 | ] 793 | } 794 | ], 795 | "metadata": { 796 | "kernelspec": { 797 | "display_name": "Python 3", 798 | "language": "python", 799 | "name": "python3" 800 | }, 801 | "language_info": { 802 | "codemirror_mode": { 803 | "name": "ipython", 804 | "version": 3 805 | }, 806 | "file_extension": ".py", 807 | "mimetype": "text/x-python", 808 | "name": "python", 809 | "nbconvert_exporter": "python", 810 | "pygments_lexer": "ipython3", 811 | "version": "3.7.6" 812 | } 813 | }, 814 | "nbformat": 4, 815 | "nbformat_minor": 4 816 | } 817 | --------------------------------------------------------------------------------