2020-05-03 課題¶

import numpy as np
import matplotlib.pyplot as plt

def koch_snowflake(order, scale=10):
    """
    Return two lists x, y of point coordinates of the Koch snowflake.

    Arguments
    ---------
    order : int
        The recursion depth.
    scale : float
        The extent of the snowflake (edge length of the base triangle).
    """
    def _koch_snowflake_complex(order):
        if order == 0:
            # initial triangle
            angles = np.array([0, 120, 240]) + 90
            return scale / np.sqrt(3) * np.exp(np.deg2rad(angles) * 1j)
        else:
            ZR = 0.5 - 0.5j * np.sqrt(3) / 3

            p1 = _koch_snowflake_complex(order - 1)  # start points
            p2 = np.roll(p1, shift=-1)  # end points
            dp = p2 - p1  # connection vectors

            new_points = np.empty(len(p1) * 4, dtype=np.complex128)
            new_points[::4] = p1
            new_points[1::4] = p1 + dp / 3
            new_points[2::4] = p1 + dp * ZR
            new_points[3::4] = p1 + dp / 3 * 2
            return new_points

    points = _koch_snowflake_complex(order)
    x, y = points.real, points.imag
    return x, y

x, y = koch_snowflake(order=5)

plt.figure(figsize=(8, 8))
plt.axis('equal')
plt.fill(x, y)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['legend.fontsize'] = 10

fig = plt.figure()
ax = fig.gca(projection='3d')


theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
z = np.linspace(-2, 2, 100)
r = z**2 + 1
x = r * np.sin(theta)
y = r * np.cos(theta)

ax.plot(x, y, z, label='parametric curve')
ax.legend()

plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi / 4, np.pi / 4)
plt.plot(x, np.sin(4 * x), label="sin 4x")
plt.plot(x, np.cos(4 * x), label="cos 4x")
plt.plot(x, np.tan(x), label="tan x")

plt.xlabel("x", size=20)
plt.ylabel("y", size=14)
plt.grid()
plt.legend()

plt.show()

from IPython.display import Math, HTML
def load_mathjax_in_cell_output():
    display(HTML("<script src='https://www.gstatic.com/external_hosted/mathjax/latest/MathJax.js?config=default'></script>"))
get_ipython().events.register('pre_run_cell', load_mathjax_in_cell_output)

x,n = symbols('x,n')

int = Integral(x**n, (x, 0, x))
print("積分それ自体を表示できる")
display(int)

積分それ自体を表示できる



<IPython.core.display.Javascript object>

print("単純な計算結果：場合分けまでしてくれるし、0 での無限大もそう書いてくれる")
display(int.doit())

単純な計算結果：場合分けまでしてくれるし、0 での無限大もそう書いてくれる



<IPython.core.display.Javascript object>

print("simplify() で 0 を消せる")
display(simplify(int.doit()))

simplify() で 0 を消せる



<IPython.core.display.Javascript object>

from IPython.display import Math, HTML
def load_mathjax_in_cell_output():
    display(HTML("<script src='https://www.gstatic.com/external_hosted/mathjax/latest/MathJax.js?config=default'></script>"))
get_ipython().events.register('pre_run_cell', load_mathjax_in_cell_output)

from IPython.display import HTML
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import scipy.integrate as integrate

I = 0.34 #external stimulus
a = 0.7
b = 0.8
c = 10

def FHN(state, t):
    """
    FitzHugh-Nagumo Equations
    u : the membrane potential
    v : a recovery variable
    """
    u, v = state
    dot_u = c * (-v + u - pow(u,3)/3 + I)
    dot_v = u - b * v + a
    return dot_u, dot_v

#initial state
u0 = 2.0
v0 = 1.0

fig = plt.figure()
t = np.arange(0.0, 10, 0.01)
len_t = len(t)
dt = 5 #time steps

#animationの1step
def update(i):
    global y, y0

    #y0の初期値の設定
    if i ==0:
        y0 = [u0, v0]

    plt.cla() #現在描写されているグラフを消去

    #微分方程式を解く
    y = integrate.odeint(FHN, y0, t)

    #1Step(=dt)後のyの値を次のステップでのy0の値に更新する
    y0 = (y[dt,0], y[dt,1])

    #配列としてu,vを取得
    u = y[:,0]
    v = y[:,1]

    #描画
    plt.plot(t, u, label="u : membrane potential", color="#ff7f0e")
    plt.plot(t, v, label="v : recovery variable", color="#1f77b4")
    plt.plot(t[len_t-1], u[len_t-1],'o--', color="#ff7f0e") #uのmarker
    plt.plot(t[len_t-1], v[len_t-1],'o--', color="#1f77b4") #vのmarker
    plt.title("Membrane Potential / Volt")
    plt.grid()
    plt.legend(bbox_to_anchor=(0, 1),
               loc='upper left',
               borderaxespad=0)

    return (u, v)

anim = animation.FuncAnimation(fig, update, interval=100,
                              frames=300)
plt.close(anim._fig)
HTML(anim.to_jshtml(default_mode='reflect'))

import numpy as np
print(type(np.array))
#print(type(np.array()))

<class 'builtin_function_or_method'>

from numpy import *
print(type(array))

<class 'builtin_function_or_method'>

a = [1,2]
print(len(a))