函数

算法

这个算法不算难。甚至可以说是非常简陋。但是在代码实现上却比之前的稍微麻烦点。主要体现在分段上。

图像效果

代码

import numpy as np
from sympy import *
import matplotlib.pyplot as plt


def f(x):
    return 1 / (1 + x ** 2)


def cal(begin, end):
    by = f(begin)
    ey = f(end)
    I = (n - end) / (begin - end) * by + (n - begin) / (end - begin) * ey
    return I


def calnf(x):
    nf = []
    for i in range(len(x) - 1):
        nf.append(cal(x[i], x[i + 1]))
    return nf


def calf(f, x):
    y = []
    for i in x:
        y.append(f.subs(n, i))
    return y


def nfSub(x, nf):
    tempx = np.array(range(11)) - 5
    dx = []
    for i in range(10):
        labelx = []
        for j in range(len(x)):
            if x[j] >= tempx[i] and x[j] < tempx[i + 1]:
                labelx.append(x[j])
            elif i == 9 and x[j] >= tempx[i] and x[j] <= tempx[i + 1]:
                labelx.append(x[j])
        dx = dx + calf(nf[i], labelx)
    return np.array(dx)


def draw(nf):
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    x = np.linspace(-5, 5, 101)
    y = f(x)
    Ly = nfSub(x, nf)
    plt.plot(x, y, label='原函数')
    plt.plot(x, Ly, label='分段线性插值函数')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.legend()

    plt.savefig('1.png')
    plt.show()


def lossCal(nf):
    x = np.linspace(-5, 5, 101)
    y = f(x)
    Ly = nfSub(x, nf)
    Ly = np.array(Ly)
    temp = Ly - y
    temp = abs(temp)
    print(temp.mean())


if __name__ == '__main__':
    x = np.array(range(11)) - 5
    y = f(x)

    n, m = symbols('n m')
    init_printing(use_unicode=True)

    nf = calnf(x)
    draw(nf)
    lossCal(nf)

龙格现象及分段线性插值

python画图代码

import numpy as np
import matplotlib.pyplot as plt


def Lagrange(arr_x, arr_y, _x):
    l = [0 for j in range(len(arr_x))]
    result = 0
    for i in range(0, len(arr_x)):
        denominator = 1
        molecular = 1
        for j in range(0, len(arr_x)):
            if i != j:
                denominator = denominator * (arr_x[i] - arr_x[j])
                molecular = molecular * (_x - arr_x[j])
        l[i] = molecular / denominator
        result = result + l[i] * arr_y[i]
    return result


original_x = np.arange(-5.0, 5.01, 0.01)
original_y = [0.0 for j in range(len(original_x))]
for i in range(len(original_y)):
    original_y[i] = 1 / (1 + original_x[i] * original_x[i])

x_arr = np.arange(-5.0, 5.5, 1)
y_arr = [0.0 for i in range(len(x_arr))]

for i in range(len(x_arr)):
    y_arr[i] = 1 / (1 + x_arr[i] ** 2)
x = np.arange(-5.0, 5.01, 0.01)
y = [0.0 for j in range(len(x))]
for i in range(len(y)):
    y[i] = Lagrange(x_arr, y_arr, x[i])

plt.plot(original_x, original_y, label='f(x) = 1 / (1 + x2)')
plt.scatter(x_arr, y_arr, label='The interpolation points')
plt.plot(x, y, label='Lagrange interpolation')
plt.plot([-5.5, 5.5], [0, 0], linestyle='--')
plt.plot([0, 0], [-0.5, 2], linestyle='--')
plt.plot(x_arr, y_arr, linestyle='--', label='piecewise linear interpolation')

plt.title("Runge phenomenon, piecewise linear interpolation")
plt.legend(loc="lower left")
plt.xlabel("x")
plt.ylabel("y")
plt.show()