You are a Python Coder Expert，I have something to ask you.

import math

def calvel(t,a,v0):
return v0+a*t

def calpos(t,a,v,s0):
return s0 + v * t + 0.5 * a * t * t

#速度规划之后 获取 当前加速度 速度 位置
def CalPosVel(movlindata, act_t, pos, vel,acc):
if ( act_t - movlindata.t[3] > 10e-6):
act_t = movlindata.t[3]

    return -1
elif(act_t - movlindata.t[0] < -10e-6):
    act_t = movlindata.t[0]

    return -1
for i in range(3):
    if(  ( act_t - movlindata.t[i] > -10e-6) and ( act_t - movlindata.t[i+1] <= 10e-6 ) ):
        acc = movlindata.a[i+1]
        vel = calvel(act_t - movlindata.t[i] , movlindata.a[i+1], movlindata.v[i])
        pos = calpos(act_t - movlindata.t[i] , movlindata.a[i+1], movlindata.v[i],movlindata.s[i] )

return pos

#input
#q0: 起始位置
#q1: 终点位置
#v0: 起始速度
#v1: 终点速度
#vmax: 最大速度
#amax: 最大加速度
#output
#time: 时间序列
#q: 位置序列
#qd: 速度序列
#qdd: 加速度序列
def TSpeedCruveMethod(q0,q1,v0,v1,vmax,amax,ts):

input q0,q1,vo,v1,vmax,amax

output time,q,qd,qdd

L = q1 - q0


v0 = v0/L
v1 = v1/L
vmax = vmax/L

amax = amax/L

v_temp = math.sqrt((2.0 * amax*(1) + (v1*v1 + v0*v0)) / 2.0)

if(v_temp<vmax):
    vlim = v_temp
else:
    vlim = vmax

Ta = (vlim-v0)/amax
Sa = v0*Ta+amax*Ta*Ta/2

Tv = (1-(vlim*vlim-v0*v0)/(2*amax)-(v1*v1-vlim*vlim)/(2*-amax))/vlim
Sv = vlim*Tv

Td = (vlim-v1)/amax
Sd = vlim*Td - amax*Td*Td/2
T = Ta + Tv +Td


T_t = [0,Ta,Ta+Tv,Ta+Tv+Td]
a_t = [0,amax,0,-amax]

v_t = [0,0,0,0]
s_t = [0,0,0,0]


for i in range(3):
    v_t[i+1] = calvel(T_t[i+1] - T_t[i],  a_t[i+1],  v_t[i])
    s_t[i+1] = calpos(T_t[i+1] - T_t[i],  a_t[i+1],  v_t[i], s_t[i] )



k = round(T/ts)

return [T_t,a_t, v_t , s_t,  k]

将以上python代码转换为C++

import robot_arm_math as robot_math
import velocity_planner as velocity_planner
import math

import numpy as np

#xyz笛卡尔速度 和旋转轴rx ry rz旋转角速度
class DynamicInfo:
vel = np.zeros((1,6))
acc = np.zeros((1,6))

class MoveLineData:
#当前时间
current_time = 0
#运行总时间
max_time = 0
#起始点齐次矩阵
start_frame = np.identity(4)

#xyz方向起点
direct_start = np.zeros((1,3))
#xyz方向长度
direct_length = np.zeros((1,3))
#总长度
total_lenth = np.zeros((1,3))

quaternion = robot_math.QuaternionData()
max_axis_number = 0 
max_time = 0.0
total_num = 0
#运动规律
t = np.array([0,0,0,0])
a = np.array([0,0,0,0])
v = np.array([0,0,0,0])
s = np.array([0,0,0,0])
totalnum = 0
Ts = 0.01
vmax = 0.0
amax = 0.0
def __init__(self):
    self.max_time = 0

def __eq__(self,other):
    if isinstance(other, MoveLineData):
        return 

#最大a v
class DynamicPara:

#位置+姿态
max_a = np.zeros((1,2))
max_v = np.zeros((1,2))
def __init__(self,dyna,dynv):
    self.max_a = dyna
    self.max_v = dynv

start起始位姿 需转 齐次矩阵 end终点位姿 需转齐次矩阵

def LinPlanner(start, end, dynamicPara, movlindata):

movlindata.max_time = 0

startmat = robot_math.EulerAngleToMat(start)
print(start)
print( "startmat @@@@@@@@@@@@@@@@@@@@@@@@@@@")
print(startmat)

movlindata.start_frame = startmat

for i in range(3):
    movlindata.direct_start[0,i] = start[i]
    movlindata.direct_length[0,i] = end[i] - start[i]

#长度
len_sum = 0.0
for i in range(3):
    len_sum = len_sum + ( movlindata.direct_length[0,i] )**2
movlindata.total_lenth[0,0] =  math.sqrt(len_sum)
#姿态规划
qs = robot_math.Eul2Quat(start[5],start[4],start[3])
qe = robot_math.Eul2Quat(end[5],end[4],end[3])

movlindata.quaternion.qs = qs
movlindata.quaternion.qe = qe

#轴角
InvQuat = robot_math.invQuat(movlindata.quaternion.qs)
deltaQuat = robot_math.MultiQuat(movlindata.quaternion.qe ,InvQuat)
QuaAxis = robot_math.GetQuaAxis(deltaQuat)
movlindata.total_lenth[0,1] = QuaAxis[0]



#位 姿优先度  确定时间最长的轴
max_axis_time = 0.0
max_axis_number = 1
act_axis_time = 0.0

for i in range(2):
    #有位移并且没有速度，报错 return 0
    act_axis_time = movlindata.total_lenth[0,i] / np.abs(  dynamicPara.max_v[0,i] )

    if(act_axis_time - max_axis_time > 1e-6):
        max_axis_time = act_axis_time
        max_axis_number = i #需要规划的轴号

q0 = 0
v0 = 0
v1 = 0

#v0  ===>v0[max_axis_number]
#v1  ===>v1[max_axis_number]
#max_v =>dynamicPara.max_v[max_axis_number]
#max_v =>dynamicPara.amax[max_axis_number]

#[q0,movlindata.total_lenth[0,max_axis_number], v0,v1,dynamicPara.max_v[0,max_axis_number],

dynamicPara.max_a[0,max_axis_number],movlindata.Ts))

[T_t, a_t, v_t, s_t,  k] = velocity_planner.TSpeedCruveMethod(q0,movlindata.total_lenth[0,max_axis_number], v0,v1,dynamicPara.max_v[0,max_axis_number],dynamicPara.max_a[0,max_axis_number],movlindata.Ts)


movlindata.max_axis_number = max_axis_number
movlindata.t = T_t
movlindata.a = a_t
movlindata.v = v_t
movlindata.s = s_t

movlindata.max_time = T_t[3]
movlindata.total_num = k

return 0

将python代码转换为C++代码