PY转易语言好像有点难度

hansiwei123 · 发表于 2024-12-13 20:26:56

import math
import os
import numpy as np
from scipy.optimize import fsolve

def predict(angel: int, wind: float, dx: float, dy: float, limited=True) -> float:
if not dx:
      return 0
if angel > 90:
      angel = 180 - angel
r, w, g = (1.08892927, 2.63945202, -155.76075737)
shot_angel = angel
position_angel = math.atan(dy / dx)
position_angel = position_angel * 180 / math.pi
x_angel = shot_angel - position_angel
y_angel = 90 - shot_angel + position_angel
x_angel = x_angel * math.pi / 180
y_angel = y_angel * math.pi / 180
position_angel = position_angel * math.pi / 180

def solve(F):
      vx = math.cos(x_angel) * F
      vy = math.cos(y_angel) * F
      fx = math.cos(position_angel) * w * wind + math.sin(position_angel) * g
      fy = -math.sin(position_angel) * w * wind + math.cos(position_angel) * g

      def computePosition(v0, f, r, t):

         temp = f - r * v0
         ert = np.power(math.e, -r * t)
         print(ert)
         right = temp * ert + f * r * t - temp
         return right / (r * r)

      def getTime(v0):
         solve_l = lambda t1: computePosition(v0, fy, r, t1)
         time = fsolve(solve_l, np.array([1]))
         assert time[0] != 0

         return time[0]
      t = getTime(vy)
      return computePosition(vx, fx, r, t) - math.sqrt(dx ** 2 + dy ** 2)

f = fsolve(solve, np.array([1]))
return min(f[0], 100)

print(predict(65,0,10,0))

有老哥帮忙下吗

补充内容 (2024-12-13 20:59):
7楼有C语言版本的。大佬们帮帮忙

后弦 · 发表于 2024-12-13 20:26:57

.版本 2

.支持库 eMath

.局部变量 angel, 整数型
.局部变量 wind, 双精度小数型
.局部变量 dx, 双精度小数型
.局部变量 dy, 双精度小数型
.局部变量 limited, 整数型
.局部变量 r, 双精度小数型
.局部变量 w, 双精度小数型
.局部变量 g, 双精度小数型
.局部变量 shot_angel, 双精度小数型
.局部变量 position_angel, 双精度小数型
.局部变量 x_angel, 双精度小数型
.局部变量 y_angel, 双精度小数型
.局部变量 F, 双精度小数型
.局部变量 vx, 双精度小数型
.局部变量 vy, 双精度小数型
.局部变量 fx, 双精度小数型
.局部变量 fy, 双精度小数型
.局部变量 t, 双精度小数型
.局部变量 result, 双精度小数型

angel ＝ 65
wind ＝ 0
dx ＝ 10
dy ＝ 0
limited ＝ 1

r ＝ 1.08892927
w ＝ 2.63945202
g ＝ -155.76075737

shot_angel ＝ angel
position_angel ＝反正切 (dy ÷ dx) × 180 ÷ 3.14159265358979323846
x_angel ＝ (shot_angel － position_angel) × 3.14159265358979323846 ÷ 180
y_angel ＝ (90 － shot_angel ＋ position_angel) × 3.14159265358979323846 ÷ 180
position_angel ＝ position_angel × 3.14159265358979323846 ÷ 180

F ＝ 1
vx ＝取余弦 (x_angel) × F
vy ＝取余弦 (y_angel) × F
fx ＝取余弦 (position_angel) × w × wind ＋取正弦 (position_angel) × g
fy ＝ -取正弦 (position_angel) × w × wind ＋取余弦 (position_angel) × g

t ＝计算时间 (vy)
result ＝计算位置 (vx, fx, r, t) －根号 (dx × dx ＋ dy × dy)

如果 (result > 100)
result ＝ 100
否则
result ＝ result
结束如果

调试输出 (结果)

.子程序计算位置, 双精度小数型, 公开
.参数 v0, 双精度小数型
.参数 f, 双精度小数型
.参数 r, 双精度小数型
.参数 t, 双精度小数型
.局部变量 temp, 双精度小数型
.局部变量 ert, 双精度小数型
.局部变量 right, 双精度小数型

temp ＝ f － r × v0
ert ＝幂 (2.718281828459045, -r × t)
right ＝ temp × ert ＋ f × r × t － temp
返回 (right ÷ (r × r))

.子程序计算时间, 双精度小数型, 公开
.参数 v0, 双精度小数型
.局部变量 solve_l, 子程序指针
.局部变量 time, 双精度小数型, , "0"
.局部变量 i, 整数型

solve_l ＝到子程序指针 (&计算位置)
time [1] ＝ 1

.判断循环首 (真)
time [1] ＝时间求解 (solve_l, time, v0, fy, r)
如果 (time [1] ≠ 0)
跳出循环 ()
结束如果
.判断循环尾 ()

返回 (time [1])

.子程序时间求解, 双精度小数型, 公开
.参数 solve_l, 子程序指针
.参数 time, 双精度小数型, 数组
.参数 v0, 双精度小数型
.参数 fy, 双精度小数型
.参数 r, 双精度小数型
.局部变量 t1, 双精度小数型
.局部变量 result, 双精度小数型

t1 ＝ time [1]
result ＝调用子程序 (solve_l, v0, fy, r, t1)
返回 (result)

补充内容 (2024-12-16 00:29):
我用AI转换成，我自己不会手动转换，只能用AI转换