HDU-ITMO – Pancake's Personal Website

说明

所有代码及答案请慎用。

可供c++在线测试平台可供java在线测试平台可供python在线测试平台1 即 vscode 。可供python在线测试平台2 即 jupyter。密码均为 hduitmo

Python 为 10.4 版本。已经安装一些基础的库，python 10.4 arm 暂不支持 geatpy, xeus-python。

可供在线测试，为树莓派，不会长期在线，网速比较慢（没有配置CDN），密码公开，注意隐私。不要乱给 ubuntu 运行命令。不要死循环、一直运行、多进程/线程占用cpu谢谢。

二重积分参考代码

class doubleIntegral:
    def __init__(self, xMin, xMax, yMin, yMax, func):
        self.xMin = xMin
        self.xMax = xMax
        self.yMin = yMin
        self.yMax = yMax
        self.func = func

    def trapezoid(self, nX, nY):
        result = 0
        betweenX = (self.xMax - self.xMin) / nX
        betweenY = (self.yMax - self.yMin) / nY
        sums = []
        for i in range(nY + 1):
            temp = 0
            for j in range(nX):
                temp += betweenX / 2 * (self.func(self.xMin + j * betweenX, self.yMin + i * betweenY) +
                                        self.func(self.xMin + (j + 1) * betweenX, self.yMin + i * betweenY))
            sums.append(temp)
        ans = 0
        for i in range(nY):
            ans += betweenY / 2 * (sums[i] + sums[i + 1])
        return ans

    def simpsons(self, nX, nY):
        result = 0
        betweenX = (self.xMax - self.xMin) / nX
        betweenY = (self.yMax - self.yMin) / nY / 2
        sums = []
        for i in range(2 * nY + 1):
            temp = 0
            for j in range(nX):
                a = self.xMin + j * betweenX
                b = self.xMin + (j + 1) * betweenX
                c = (a + b) / 2
                temp += betweenX / 6 * (self.func(a, self.yMin + i * betweenY) + self.func(
                    b, self.yMin + i * betweenY) + 4 * self.func(c, self.yMin + i * betweenY))
            sums.append(temp)
        ans = 0
        for i in range(nY):
            ans += betweenY / 3 * \
                (sums[i * 2] + sums[(i + 1) * 2] + 4 * sums[i * 2 + 1])
        return ans


if __name__ == "__main__":
    # 个人不知道为什么梯形法求出来不对，有兴趣的可以自己去看看
    # 输入格式：xMin, xMax, yMin, yMax, func
    # 输入格式'： nx, ny
    print(doubleIntegral(0, 1, 0, 2, lambda x, y: x**2+2*y).trapezoid(4, 8))
    print(doubleIntegral(0, 1, 0, 2, lambda x, y: x**2+2*y).simpsons(4, 8))

class doubleIntegral:

def __init__(self, xMin, xMax, yMin, yMax, func):

self.xMin = xMin

self.xMax = xMax

self.yMin = yMin

self.yMax = yMax

self.func = func

def trapezoid(self, nX, nY):

result = 0

betweenX = (self.xMax - self.xMin) / nX

betweenY = (self.yMax - self.yMin) / nY

sums = []

for i in range(nY + 1):

temp = 0

for j in range(nX):

temp += betweenX / 2 * (self.func(self.xMin + j * betweenX, self.yMin + i * betweenY) +

self.func(self.xMin + (j + 1) * betweenX, self.yMin + i * betweenY))

sums.append(temp)

ans = 0

for i in range(nY):

ans += betweenY / 2 * (sums[i] + sums[i + 1])

return ans

def simpsons(self, nX, nY):

result = 0

betweenX = (self.xMax - self.xMin) / nX

betweenY = (self.yMax - self.yMin) / nY / 2

sums = []

for i in range(2 * nY + 1):

temp = 0

for j in range(nX):

a = self.xMin + j * betweenX

b = self.xMin + (j + 1) * betweenX

c = (a + b) / 2

temp += betweenX / 6 * (self.func(a, self.yMin + i * betweenY) + self.func(

b, self.yMin + i * betweenY) + 4 * self.func(c, self.yMin + i * betweenY))

sums.append(temp)

ans = 0

for i in range(nY):

ans += betweenY / 3 * \

(sums[i * 2] + sums[(i + 1) * 2] + 4 * sums[i * 2 + 1])

return ans

if __name__ == "__main__":

# 个人不知道为什么梯形法求出来不对，有兴趣的可以自己去看看

# 输入格式：xMin, xMax, yMin, yMax, func

# 输入格式'： nx, ny

print(doubleIntegral(0, 1, 0, 2, lambda x, y: x**2+2*y).trapezoid(4, 8))

print(doubleIntegral(0, 1, 0, 2, lambda x, y: x**2+2*y).simpsons(4, 8))

2022.5发展对象答辩

关于最终通过名单个人结论及给你的建议：

学院现最高本科生为 19 级，发展优先级：研究生全部，19级 >> 20级。
20级单一标准：志愿时长及对学院贡献（指党建等各项学院工作，非科研竞赛）。对社会贡献>>科研竞赛。

所以dddd，如果你要准备在HDU-ITMO入党：

提高你在学院影响力，学习不能差，多拿奖学金，争取先成为发展分子。
志愿/学院党建等工作/对社会有卓越贡献。
搞科研等大三/大四。

计算数学 ODE LAB 3

全部是正确答案，慎用。Adams和Milne需要用另外的算法如runge-kutta（代码示例求法）求前3个数，当然也可以用Euler和Euler Improved，大家不要都一样啦。Python缩进规范请注意！

Python Euler Improved

def solveByEulerImproved(f, epsilon, a, y_a, b):
        function = Result.get_function(f)
        n = 1
        delta = float("inf")
        while abs(delta) >= epsilon / 10:
            n *= 2
            h = (b - a) / n
            pre_y = y_a
            pre_fy = function(a, y_a)
            for i in range(n):
                x = a + (i + 1 / 2) * h
                yHalf = pre_y + pre_fy * h / 2
                fyHalf = function(x, yHalf)
                y = pre_y + h * fyHalf
                delta = pre_y - y
                pre_y = y
                pre_fy = function(x + h / 2, y)
        return y

def solveByEulerImproved(f, epsilon, a, y_a, b):

function = Result.get_function(f)

n = 1

delta = float("inf")

while abs(delta) >= epsilon / 10:

n *= 2

h = (b - a) / n

pre_y = y_a

pre_fy = function(a, y_a)

for i in range(n):

x = a + (i + 1 / 2) * h

yHalf = pre_y + pre_fy * h / 2

fyHalf = function(x, yHalf)

y = pre_y + h * fyHalf

delta = pre_y - y

pre_y = y

pre_fy = function(x + h / 2, y)

return y

Python Euler

Euler method 理论上代码正确，但是实际上因为算法的原因，与测试样例的值偏差会过大，要通过测试样例只需要初始化时把 n = 10000000

def solveByEuler(f, epsilon, a, y_a, b):
    function = Result.get_function(f)
    n = 1
    delta = float("inf")
    while abs(delta) >= epsilon / 10:
        n *= 2
        h = (b - a) / n
        pre_y = y_a
        for i in range(n):
            x = a + i * h
            fy = function(x, pre_y)
            y = pre_y + h * fy
            delta = pre_y - y
            pre_y = y
    return y

def solveByEuler(f, epsilon, a, y_a, b):

function = Result.get_function(f)

n = 1

delta = float("inf")

while abs(delta) >= epsilon / 10:

n *= 2

h = (b - a) / n

pre_y = y_a

for i in range(n):

x = a + i * h

fy = function(x, pre_y)

y = pre_y + h * fy

delta = pre_y - y

pre_y = y

return y

Python Runge-Kutta

def solveByRungeKutta(f, epsilon, a, y_a, b):
    function = Result.get_function(f)
    n = 1
    delta = float("inf")
    while abs(delta) >= epsilon / 10:
        n *= 2
        h = (b - a) / n
        pre_y = y_a
        for i in range(n):
            x = a + i * h
            k1 = h * function(x, pre_y)
            k2 = h * function(x + h / 2, pre_y + k1 / 2)
            k3 = h * function(x + h / 2, pre_y + k2 / 2)
            k4 = h * function(x + h, pre_y + k3)
            y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y
            delta = pre_y - y
            pre_y = y
    return y

def solveByRungeKutta(f, epsilon, a, y_a, b):

function = Result.get_function(f)

n = 1

delta = float("inf")

while abs(delta) >= epsilon / 10:

n *= 2

h = (b - a) / n

pre_y = y_a

for i in range(n):

x = a + i * h

k1 = h * function(x, pre_y)

k2 = h * function(x + h / 2, pre_y + k1 / 2)

k3 = h * function(x + h / 2, pre_y + k2 / 2)

k4 = h * function(x + h, pre_y + k3)

y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y

delta = pre_y - y

pre_y = y

return y

Python Adams

def runge_kutta(h, a, y_a, function):
    y_dot = [function(a, y_a)]
    pre_y = y_a
    for i in range(3):
        x = a + i * h
        k1 = h * function(x, pre_y)
        k2 = h * function(x + h / 2, pre_y + k1 / 2)
        k3 = h * function(x + h / 2, pre_y + k2 / 2)
        k4 = h * function(x + h, pre_y + k3)
        y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y
        y_dot.append(function(x + h, y))
        pre_y = y
    return y, y_dot


def solveByAdams(f, epsilon, a, y_a, b):
    function = Result.get_function(f)
    n = 2
    delta = float("inf")
    while abs(delta) >= epsilon / 10:
        n *= 2
        h = (b - a) / n
        y, y_dot = Result.runge_kutta(h, a, y_a, function)
        for i in range(n - 3):
            delta = (55 * y_dot[-1] - 59 * y_dot[-2] + 37 * y_dot[-3] - 9 * y_dot[-4]) / 24 * h
            y += delta
            y_dot.append(function(a + (i + 4) * h, y))
    return y

def runge_kutta(h, a, y_a, function):

y_dot = [function(a, y_a)]

pre_y = y_a

for i in range(3):

x = a + i * h

k1 = h * function(x, pre_y)

k2 = h * function(x + h / 2, pre_y + k1 / 2)

k3 = h * function(x + h / 2, pre_y + k2 / 2)

k4 = h * function(x + h, pre_y + k3)

y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y

y_dot.append(function(x + h, y))

pre_y = y

return y, y_dot

def solveByAdams(f, epsilon, a, y_a, b):

function = Result.get_function(f)

n = 2

delta = float("inf")

while abs(delta) >= epsilon / 10:

n *= 2

h = (b - a) / n

y, y_dot = Result.runge_kutta(h, a, y_a, function)

for i in range(n - 3):

delta = (55 * y_dot[-1] - 59 * y_dot[-2] + 37 * y_dot[-3] - 9 * y_dot[-4]) / 24 * h

y += delta

y_dot.append(function(a + (i + 4) * h, y))

return y

Python Milne

def runge_kutta(h, a, y_a, function):
    y_dot = [function(a, y_a)]
    y_ = [y_a]
    pre_y = y_a
    for i in range(3):
        x = a + i * h
        k1 = h * function(x, pre_y)
        k2 = h * function(x + h / 2, pre_y + k1 / 2)
        k3 = h * function(x + h / 2, pre_y + k2 / 2)
        k4 = h * function(x + h, pre_y + k3)
        y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y
        y_dot.append(function(x + h, y))
        y_.append(y)
        pre_y = y
    return y_, y_dot


def solveByMilne(f, epsilon, a, y_a, b):
    function = Result.get_function(f)
    n = 2
    delta = float("inf")
    while abs(delta) >= epsilon / 10:
        n *= 2
        h = (b - a) / n
        y, y_dot = Result.runge_kutta(h, a, y_a, function)
        for i in range(n - 3):
            y.append(y[-4] + 4 * h / 3 * (2 * y_dot[-1] - y_dot[-2] + 2 * y_dot[-3]))
            y_dot.append(function(a + (i + 4) * h, y[-1]))
            y[-1] = y[-3] + h / 3 * (y_dot[-1] + 4 * y_dot[-2] + y_dot[-3])
            delta = y[-1] - y[-2]
            y_dot[-1] = function(a + (i + 4) * h, y[-1])
    return y[-1]

def runge_kutta(h, a, y_a, function):

y_dot = [function(a, y_a)]

y_ = [y_a]

pre_y = y_a

for i in range(3):

x = a + i * h

k1 = h * function(x, pre_y)

k2 = h * function(x + h / 2, pre_y + k1 / 2)

k3 = h * function(x + h / 2, pre_y + k2 / 2)

k4 = h * function(x + h, pre_y + k3)

y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y

y_dot.append(function(x + h, y))

y_.append(y)

pre_y = y

return y_, y_dot

def solveByMilne(f, epsilon, a, y_a, b):

function = Result.get_function(f)

n = 2

delta = float("inf")

while abs(delta) >= epsilon / 10:

n *= 2

h = (b - a) / n

y, y_dot = Result.runge_kutta(h, a, y_a, function)

for i in range(n - 3):

y.append(y[-4] + 4 * h / 3 * (2 * y_dot[-1] - y_dot[-2] + 2 * y_dot[-3]))

y_dot.append(function(a + (i + 4) * h, y[-1]))

y[-1] = y[-3] + h / 3 * (y_dot[-1] + 4 * y_dot[-2] + y_dot[-3])

delta = y[-1] - y[-2]

y_dot[-1] = function(a + (i + 4) * h, y[-1])

return y[-1]

计算数学 ODE Python参考代码

class ODE:
    def __init__(self, function, x0, y0):
        self.function = function
        self.x0 = x0
        self.y0 = y0

    def euler(self, h, step):
        result = []
        pre_y = self.y0
        for i in range(step):
            x = self.x0 + i * h
            fy = self.function(x, pre_y)
            y = pre_y + h * fy
            result.append(y)
            pre_y = y
            # print("y_{} = {}".format(i + 1, y))
        return result

    def eulerImproved(self, h, step):
        result = []
        pre_y = self.y0
        pre_fy = self.y0
        for i in range(step):
            x = self.x0 + (i + 1 / 2) * h
            yHalf = pre_y + pre_fy * h / 2
            fyHalf = self.function(x, yHalf)
            y = pre_y + h * fyHalf
            result.append(y)
            pre_y = y
            pre_fy = function(x + h / 2, y)
            # print("y_{} = {}".format(i + 1, y))
        return result

    def runge_kutta(self, h, step):
        result = []
        pre_y = self.y0
        for i in range(step):
            x = self.x0 + i * h
            k1 = h * self.function(x, pre_y)
            k2 = h * self.function(x + h / 2, pre_y + k1 / 2)
            k3 = h * self.function(x + h / 2, pre_y + k2 / 2)
            k4 = h * self.function(x + h, pre_y + k3)
            y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y
            result.append(y)
            pre_y = y
            # print("y_{} = {}".format(i + 1, y))
        return result

    def milne(self, h, step):
        y = [self.y0] + self.runge_kutta(h, 3)
        y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]
        for i in range(step - 3):
            y.append(y[-4] + 4 * h / 3 * (2 * y_dot[-1] - y_dot[-2] + 2 * y_dot[-3]))
            y_dot.append(function(self.x0 + (i + 4) * h, y[-1]))
            y[-1] = y[-3] + h / 3 * (y_dot[-1] + 4 * y_dot[-2] + y_dot[-3])
            y_dot[-1] = function(self.x0 + (i + 4) * h, y[-1])
            # print("y_{} = {}".format(i + 4, y[-1]))
        return y[1:]

    def adams(self, h, step):
        y = [self.y0] + self.runge_kutta(h, 3)
        y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]
        for i in range(step - 3):
            y.append(y[-1] + (55 * y_dot[-1] - 59 * y_dot[-2] + 37 * y_dot[-3] - 9 * y_dot[-4]) / 24 * h)
            y_dot.append(function(self.x0 + (i + 4) * h, y[-1]))
            # print("y_{} = {}".format(i + 4, y[-1]))
        return y[1:]


if __name__ == "__main__":
    function = lambda x, y: y - 2 * x / y
    x0 = 0
    y0 = 1
    h = 0.002
    step = 1000
    ode = ODE(function, x0, y0)
    print(ode.euler(h, step)[-1])
    print("--------------------------------------------")
    print(ode.eulerImproved(h, step)[-1])
    print("--------------------------------------------")
    print(ode.runge_kutta(h, step)[-1])
    print("--------------------------------------------")
    print(ode.adams(h, step)[-1])
    print("--------------------------------------------")
    print(ode.milne(h, step)[-1])

class ODE:

def __init__(self, function, x0, y0):

self.function = function

self.x0 = x0

self.y0 = y0

def euler(self, h, step):

result = []

pre_y = self.y0

for i in range(step):

x = self.x0 + i * h

fy = self.function(x, pre_y)

y = pre_y + h * fy

result.append(y)

pre_y = y

# print("y_{} = {}".format(i + 1, y))

return result

def eulerImproved(self, h, step):

result = []

pre_y = self.y0

pre_fy = self.y0

for i in range(step):

x = self.x0 + (i + 1 / 2) * h

yHalf = pre_y + pre_fy * h / 2

fyHalf = self.function(x, yHalf)

y = pre_y + h * fyHalf

result.append(y)

pre_y = y

pre_fy = function(x + h / 2, y)

# print("y_{} = {}".format(i + 1, y))

return result

def runge_kutta(self, h, step):

result = []

pre_y = self.y0

for i in range(step):

x = self.x0 + i * h

k1 = h * self.function(x, pre_y)

k2 = h * self.function(x + h / 2, pre_y + k1 / 2)

k3 = h * self.function(x + h / 2, pre_y + k2 / 2)

k4 = h * self.function(x + h, pre_y + k3)

y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y

result.append(y)

pre_y = y

# print("y_{} = {}".format(i + 1, y))

return result

def milne(self, h, step):

y = [self.y0] + self.runge_kutta(h, 3)

y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]

for i in range(step - 3):

y.append(y[-4] + 4 * h / 3 * (2 * y_dot[-1] - y_dot[-2] + 2 * y_dot[-3]))

y_dot.append(function(self.x0 + (i + 4) * h, y[-1]))

y[-1] = y[-3] + h / 3 * (y_dot[-1] + 4 * y_dot[-2] + y_dot[-3])

y_dot[-1] = function(self.x0 + (i + 4) * h, y[-1])

# print("y_{} = {}".format(i + 4, y[-1]))

return y[1:]

def adams(self, h, step):

y = [self.y0] + self.runge_kutta(h, 3)

y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]

for i in range(step - 3):

y.append(y[-1] + (55 * y_dot[-1] - 59 * y_dot[-2] + 37 * y_dot[-3] - 9 * y_dot[-4]) / 24 * h)