18.2019 华为杯研究生数学建模D题部分代码

最新推荐文章于 2023-09-22 12:00:34 发布
最新推荐文章于 2023-09-22 12:00:34 发布
阅读量3.3k 收藏 24
点赞数 3
分类专栏： python 文章标签： 数学建模
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42197919/article/details/102636630
版权 
# @File  : math.py
# @Author: Wang Zhimin
# @Date  : 2019/9/19
import numpy as np
import pandas as pd
from pandas import DataFrame
import matplotlib.pyplot as plt
import matplotlib as mpl
from sklearn import tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder
import pydotplus
from scipy.interpolate import interp1d
def sgn(x):
    if x<0:
        return -1
    elif x==0:
        return 0
    else:
        return 1



plt.plot(x_pred,y1,'r',label='linear')
plt.plot(x_pred,y2,'b--',label='cubic')
plt.legend()
plt.show()

excel_data = pd.read_excel("D:/stu/2019年中国研究生数学建模竞赛赛题 (2)/2019年中国研究生数学建模竞赛D题/原始数据/文件1.xlsx")
test_excel_data=pd.read_excel("D:/stu/2019年中国研究生数学建模竞赛赛题 (2)/2019年中国研究生数学建模竞赛D题/原始数据/文件1_1.xlsx")
excel_data["加速度1"]
excel_data["加速度1"]=pow(pow(excel_data["X轴加速度"],2)+pow(excel_data["Y轴加速度"],2)+pow(excel_data["Z轴加速度"],2),1/2)
print(excel_data.loc[10].values)#最后一行

print(excel_data.iloc[0, 0][17:])
hangshu=excel_data.shape[0]#11
lieshu=excel_data.shape[1]#12







换成秒
for i in range(0,hangshu):
    excel_data.iloc[i, 0]=int(excel_data.iloc[i, 0][17:19])
    print(i)
print(excel_data.iloc[3, 0]-excel_data.iloc[2, 0])


#GPS不连续的问题
插值法
sixty=0
yibaiwu=0
sanbai=0
wubai=0
babai=0
yiqian=0
yiqianwu=0
erqian=0
not_continunes_num=0
for i in range(0,hangshu-1):
    if abs(int(excel_data.iloc[i+1, 0][17:19])-int(excel_data.iloc[i, 0][17:19]))!=1 and abs(int(excel_data.iloc[i+1, 0][17:19])-int(excel_data.iloc[i, 0][17:19]))!=59  :
        print("GPS不连续的问题",i+2,excel_data.iloc[i+1, 0])
        not_continunes_num=not_continunes_num+1
        # #判断个数
        num_test=abs(int(excel_data.iloc[i+1, 0][11:13])*3600+int(excel_data.iloc[i + 1, 0][14:16]) * 60 + int(excel_data.iloc[i + 1, 0][17:19])) - abs(int(excel_data.iloc[i, 0][11:13])*3600+int(excel_data.iloc[i, 0][14:16]) * 60 + int(excel_data.iloc[i, 0][17:19]))
        #
        if num_test<50:
            sixty=sixty+1
        elif num_test<100:
            yibaiwu = yibaiwu + 1
        elif num_test<300:
            sanbai = sanbai + 1
        elif num_test<500:
            wubai = wubai + 1
        elif num_test<800:
            babai = babai + 1
        elif num_test<1000:
            yiqian = yiqian + 1
        elif num_test<1500:
            yiqianwu = yiqianwu + 1
        elif num_test>2000:
            erqian = erqian + 1

        print(num_test)
        print((abs(int(excel_data.iloc[i+1, 0][11:13])*3600+int(excel_data.iloc[i + 1, 0][14:16]) * 60 + int(excel_data.iloc[i + 1, 0][17:19])) - abs(int(excel_data.iloc[i, 0][11:13])*3600+int(excel_data.iloc[i, 0][14:16]) * 60 + int(excel_data.iloc[i, 0][17:19]))))
        if abs(abs(int(excel_data.iloc[i+1, 0][11:13])*3600+int(excel_data.iloc[i + 1, 0][14:16]) * 60 + int(excel_data.iloc[i + 1, 0][17:19])) - abs(int(excel_data.iloc[i, 0][11:13])*3600+int(excel_data.iloc[i, 0][14:16]) * 60 + int(excel_data.iloc[i, 0][17:19])))<60:
            print("GPS不连续的问题<60", i + 2, excel_data.iloc[i + 1, 0])
            num = abs(int(excel_data.iloc[i + 1, 0][14:16]) * 60 + int(excel_data.iloc[i + 1, 0][17:19])) - abs(
                int(excel_data.iloc[i, 0][14:16]) * 60 + int(excel_data.iloc[i, 0][17:19]))
            # y = [excel_data.iloc[i - 1, 1], excel_data.iloc[i - 2, 1], excel_data.iloc[i - 3, 1],
            #      excel_data.iloc[i - 4, 1], excel_data.iloc[i - 5, 1],
            #      excel_data.iloc[i + 1, 1], excel_data.iloc[i + 2, 1], excel_data.iloc[i + 3, 1],
            #      excel_data.iloc[i + 4, 1], excel_data.iloc[i + 5, 1]]
            # x = [int(excel_data.iloc[i - 1, 0][17:19]), int(excel_data.iloc[i - 2, 0][17:19]), int(excel_data.iloc[i - 3, 0][17:19]),
            #      int(excel_data.iloc[i - 4, 0][17:19]), int(excel_data.iloc[i - 5, 0][17:19]),
            #      int(excel_data.iloc[i, 0][17:19])+num, int(excel_data.iloc[i , 0][17:19])+num+1, int(excel_data.iloc[i, 0][17:19])+num+2,
            #      int(excel_data.iloc[i, 0][17:19])+num+3, int(excel_data.iloc[i, 0][17:19])+num+4]
            y = [excel_data.iloc[i , 1],
                 excel_data.iloc[i + 1, 1]]
            x = [int(excel_data.iloc[i, 0][17:19]),
                 int(excel_data.iloc[i, 0][17:19]) + num ]

            f2 = interp1d(x, y, kind='slinear')  # 三次样条插值

            print("num",num)
            print("int(excel_data.iloc[i, 0][17:19])",int(excel_data.iloc[i, 0][17:19]))
            print("int(excel_data.iloc[i + 1, 0][17:19])", int(excel_data.iloc[i + 1, 0][17:19]))

            for chazhi in range(int(excel_data.iloc[i, 0][17:19]),int(excel_data.iloc[i, 0][17:19])+num,1):

                if chazhi ==int(excel_data.iloc[i, 0][17:19]):
                    continue
                y2 = f2(chazhi)
                nian=int(excel_data.iloc[i, 0][0:4])
                yue=int(excel_data.iloc[i, 0][5:7])
                ri=int(excel_data.iloc[i, 0][8:10])
                shi=int(excel_data.iloc[i, 0][11:13])
                fen=int(excel_data.iloc[i, 0][14:16])

                if chazhi>=60:
                    chazhi=chazhi-60
                    fen = int(excel_data.iloc[i, 0][14:16])+1
                    fen='%02d'%fen
                chazhi = '%02d' % int(chazhi)
                mingzi=str(nian) + '/' + str(yue) + "/" + str(ri) + " " + str(shi) + ":" + str(fen) + ":" + str(
                    chazhi) + ".000"
                excel_data.loc[mingzi] = [mingzi, y2, '0', '0',
                                               '0', '0','0', '0', '0', '0', '0', '0', '0', '2.25', '0', '0']
                print(str(nian)+'/'+str(yue)+"/"+str(ri)+" "+str(shi)+":"+str(fen)+":" + str(chazhi) + ".000")
    #
    else:
        pass
# 算加速度
# for i in range(0,hangshu-1):  # 迭代 10 到 20 之间的数字
#     # excel_data.iloc[i+1, lieshu-2]= sgn(excel_data.iloc[i+1, 1]-excel_data.iloc[i, 1]) * excel_data.iloc[i + 1, lieshu - 1]
#     excel_data.iloc[i + 1, lieshu - 2] = (excel_data.iloc[i + 1, 1] - excel_data.iloc[i, 1])/3.6
# 算加速度
print("<60:",sixty)
print(">60,,<150:",yibaiwu)
print(">150,,<300::",sanbai)
print(">300,,<500::",wubai)
print(">500,,<800::",babai)
print(">800,,<1000::",yiqian)
print(">1000,,<1500::",yiqianwu)
print(">1500,,<2000::",erqian)
print("不连续总共有多少段:",not_continunes_num)




# 普通轿车一般情况下：0至100km/h的加速时间大于7秒，

star=0
over=0


for i in range(0,hangshu-1):
    t = t + 1
    # print(excel_data.iloc[i, 15])
    if test_excel_data.iloc[i, 14]>=0.1  and abs(float(test_excel_data.iloc[i+1, 0][17:19])-float(test_excel_data.iloc[i, 0][17:19]))==1 or abs(float(test_excel_data.iloc[i+1, 0][17:19])-float(test_excel_data.iloc[i, 0][17:19]))==59 :
        if t==1:
            star=i
        if t>7:
            print("0至100km/h的加速时间大于7秒:",test_excel_data.iloc[i, 14],i+2)
            excel_data=excel_data.drop(i, axis=0)
        if t==7:
            over=i
            excel_data=excel_data.drop([star,over], axis=0)

    else:
        t=0
        star = 0
        over = 0
print(test_excel_data.iloc[46, 14]-0.1)
t=0
for i in range(0,hangshu-1):
    t = t + 1
    # print(excel_data.iloc[i, 15])
    if (excel_data.iloc[i, 14]-0.1)>0 and excel_data.iloc[i, 1]>100 and (abs(float(excel_data.iloc[i+1, 0][17:19])-float(excel_data.iloc[i, 0][17:19]))==1 or abs(float(excel_data.iloc[i+1, 0][17:19])-float(excel_data.iloc[i, 0][17:19]))==59 ):
        if t<=7:
            print("0至100km/h的加速时间大于7秒:",excel_data.iloc[i, 14],i+2)
    else:
        t=0




# #般认为怠速时间超过180秒为异常情况，怠速最长时间可按180秒处理
t2=0

print(excel_data.iloc[0, 1])
for i in range(0,hangshu-1):
    if (test_excel_data.iloc[i, 1]<10 or test_excel_data.iloc[i, 1]==0 ) and( abs(float(test_excel_data.iloc[i+1, 0][17:19])-float(test_excel_data.iloc[i, 0][17:19]))==1 or abs(float(test_excel_data.iloc[i+1, 0][17:19])-float(test_excel_data.iloc[i, 0][17:19]))==59)  :
        t2=t2+1
        if t2>180:
            print("0至100km/般认为怠速时间超过180秒为异常情况，怠速最长时间可按180秒处理:",excel_data.iloc[i, 1],i+2)
            excel_data.iloc[i, 1]=8888
    else:
        t2=0


# 紧急刹车最大减速度在7.5~8 m/s2

for i in range(0,hangshu-1):

    # print(excel_data.iloc[i, 15])
    if test_excel_data.iloc[i, 14]<= -8  and (abs(float(test_excel_data.iloc[i+1, 0][17:19])-float(test_excel_data.iloc[i, 0][17:19]))==1 or abs(float(test_excel_data.iloc[i+1, 0][17:19])-float(test_excel_data.iloc[i, 0][17:19]))==59) :
        print("紧急刹车最大减速度在7.5~8 m/s2:",excel_data.iloc[i, 14],i+2)
        # excel_data = excel_data.drop(i, axis=0)
    else:
        pass



#算T TI
T=hangshu
print("T:",T)
Ti=excel_data["GPS车速"].value_counts()
print("TI:",Ti)
Ti=5
算Ta
Ta=excel_data.loc[(excel_data["加速度"]>=0.1)].count()
print(Ta)


算Td
Ta=excel_data.loc[(excel_data["加速度"]<=-0.1)].count()
# print(Ta)

s ,Vmax ,Vm xlsx做
S_TEST=142.41
print("S_TEST:",S_TEST)
Vmax_TEST=60
print("Vmax_TEST:",Vmax_TEST)
Vm_TeST=S_TEST/T
print("Vm_TeST:",Vm_TeST)
Vmr=S_TEST/(T-Ti)
print("Vmr:",Vmr)

Vs_TEST=pow((1/(T-1))*sum(pow((excel_data["GPS车速"]-Vm_TeST),2)),1/2)
print("Vs_TEST:",Vs_TEST)

print(pow((excel_data["GPS车速"]-Vm_TeST),2))


从怠速状态开始至下一个怠速状态开始之间的车速区间

temp=dict()
for i in range(0,hangshu):
    temp[str(i)] =excel_data.iloc[i , 1]
print(temp)
print(temp.values())
t=0
j=0
for i in temp.values():
    # print(i)
    # if i==0:
    #     print("yes")
    # else:
    #     print("no")
    if i==0:
        t=t+1
        if t>1:
            temp[str(j)]=1
    if i!=0:
        t=0
    j=j+1
print(temp)
daishu_time=0
cishu=0
cishu_1=0
chushu_2=0

control_key=0
key=0
key1=0
pianduangeshu=0
bigger_than_1000=0
smaller_50=0
smaller_100=0
samller_300=0
smaller_500=0
smaller_800=0
for i in temp.values():
    if i==0 :
        if control_key==0:
            cishu_1=key
            control_key = control_key+1
        if cishu!=0 and i==0 and control_key==1:
            cishu_2 = key1
            daishu_time =cishu_2-cishu_1
            pianduangeshu = pianduangeshu+1
            if pianduangeshu>1000:
                bigger_than_1000=bigger_than_1000+1
            if pianduangeshu<50:
                smaller_50=smaller_50+1
            if pianduangeshu>50 and pianduangeshu<100:
                smaller_100=smaller_100+1
            if pianduangeshu>50 and pianduangeshu<100:
                smaller_100=smaller_100+1
            if pianduangeshu>100 and pianduangeshu<300:
                samller_300=samller_300+1
            if pianduangeshu>300 and pianduangeshu<500:
                smaller_500=smaller_500+1
            if pianduangeshu>500 and pianduangeshu<800:
                smaller_800=smaller_800+1
            print("from "+str(cishu_1)+"to"+str(cishu_2)+ "all second is "+str(daishu_time))

            # 画图
            x_picture = []
            Y_picture = []
            for zz in range(cishu_1, cishu_2):
                x_picture.append(zz)
                Y_picture.append(excel_data.iloc[zz, 1])
            if pianduangeshu > 300:
                plt.plot(x_picture, Y_picture, linestyle='dashed', linewidth=0.5, color='red' )

                plt.xlabel('value of Time')
                plt.ylabel('value of Speed')
                plt.savefig("C:/Users/wangz/Desktop/图片/文件2图片/" + str(pianduangeshu) + ".jpg")
                # plt.show()
            x_picture.clear()
            Y_picture.clear()
            画图

            T=cishu_2-cishu_1+1
            excel_data.iloc[pianduangeshu-1, 15]=T
            Ti=0
            Ta=0
            Td=0
            s=0
            v=[]
            a=[]
            amax=[]
            amin=[]
            for z in range(cishu_1,cishu_2):
                s=excel_data.iloc[z , 1]+s
                v.append(excel_data.iloc[z , 1])
                a.append(excel_data.iloc[z , 14])
                if excel_data.iloc[z , 14]>0.1:
                    amax.append(excel_data.iloc[z , 14])
                if excel_data.iloc[z , 14]<-0.1:
                    amin.append(excel_data.iloc[z , 14])
                if excel_data.iloc[z, 1]==0:
                    Ti=Ti+1
                if excel_data.iloc[z, 14]>0.1:
                    Ta = Ta + 1
                if excel_data.iloc[z, 14]<-0.1:
                    Td = Td + 1
            if Td==0:
                Td=1
            if Ta==0:
                Ta=1
            excel_data.iloc[pianduangeshu - 1, 16] = Ti
            excel_data.iloc[pianduangeshu - 1, 17] = Ta
            excel_data.iloc[pianduangeshu - 1, 18] = Td
            excel_data.iloc[pianduangeshu - 1, 19] = T-Ti-Ta-Td
            excel_data.iloc[pianduangeshu - 1, 20] = s
            excel_data.iloc[pianduangeshu - 1, 21] =max(v)
            Vm = s/T
            Vmr=s / (T-Ti)
            excel_data.iloc[pianduangeshu - 1, 22] = Vm
            excel_data.iloc[pianduangeshu - 1, 23] = Vmr
            Vs=sum(pow(v - Vm, 2)) / (T - 1)
            excel_data.iloc[pianduangeshu - 1, 24]=Vs
            #print("a",a)
            Amax=max(a)
            Am=sum(amax) / Ta
            Dmax=min(a)
            Dmin=sum(amin) / Td
            excel_data.iloc[pianduangeshu - 1, 25]=Amax
            excel_data.iloc[pianduangeshu - 1, 26] = Am
            excel_data.iloc[pianduangeshu - 1, 27] =Dmax
            excel_data.iloc[pianduangeshu - 1, 28] = Dmin
            a_2=[]
            for xx in a:
                a_2.append(pow(xx, 2))
            As=pow(sum(a_2)/(T-1),1/2)
            excel_data.iloc[pianduangeshu - 1, 29] = As
            Pi=Ti/T
            Pa=Ta/T
            Pd=Td/T
            Pe=1-Pi-Pa-Pd
            excel_data.iloc[pianduangeshu - 1, 30] =Pi
            excel_data.iloc[pianduangeshu - 1, 31] =Pa
            excel_data.iloc[pianduangeshu - 1, 32] =Pd
            excel_data.iloc[pianduangeshu - 1, 33] =Pe






            cishu_1=cishu_2
    cishu = cishu + 1
    key = key+1
    key1 = key1 + 1
print("片段个数一共有",pianduangeshu)
print("片段小于50s",smaller_50)
print("片段大于50s，小于100",smaller_100)
print("片段大于100s，小于300",samller_300)
print("片段大于300s，小于500",smaller_500)
print("片段大于500s，小于800",smaller_800)
print("片段大于1000s数",bigger_than_1000)

#从怠速状态开始至下一个怠速状态开始之间的车速区间
#生成特征参数、构建工况图、拼接图

temp=dict()
for i in range(0,hangshu):
    temp[str(i)] =excel_data.iloc[i , 1]
print(temp)
print(temp.values())
t=0
j=0
for i in temp.values():
    # print(i)
    # if i==0:
    #     print("yes")
    # else:
    #     print("no")
    if i==0:
        t=t+1
        if t>1:
            temp[str(j)]=1
    if i!=0:
        t=0
    j=j+1
print(temp)
daishu_time=0
cishu=0
cishu_1=0
chushu_2=0

control_key=0
key=0
key1=0
pianduangeshu=0
x_picture = []
Y_picture = []
a_last=[]
v_last=[]
T_l=[]
Ti_l=[]
Ta_l=[]
Td_l=[]
Te_l=[]
S_l=[]
Vmax_l=[]
Vm_l=[]
Vmr_l=[]
Vs_l=[]
Amax_l=[]
Am_l=[]
Dmax_l=[]
Dm_l=[]
As_l=[]
Pi_l=[]
Pa_l=[]
Pd_l=[]
Pe_l=[]
for i in temp.values():
    if i==0 :
        if control_key==0:
            cishu_1=key
            control_key = control_key+1
        if cishu!=0 and i==0 and control_key==1:
            cishu_2 = key1
            daishu_time =cishu_2-cishu_1
            pianduangeshu = pianduangeshu+1
            print("from "+str(cishu_1)+"to"+str(cishu_2)+ "all second is "+str(daishu_time))

            画图

            if pianduangeshu==136 or pianduangeshu==139 or pianduangeshu== 188 or pianduangeshu== 219 or pianduangeshu== 122 or pianduangeshu ==111 or pianduangeshu==347 or pianduangeshu==190 or pianduangeshu== 140 or pianduangeshu==145 or pianduangeshu==146 or pianduangeshu==147 or pianduangeshu==182:
                # print("excel_data.iloc[pianduangeshu, 15]",excel_data.iloc[pianduangeshu-2, 15])
            #
                for zz in range(cishu_1, cishu_2):
                    a_last.append(excel_data.iloc[zz-2, 14])
                    v_last.append(excel_data.iloc[zz-2, 1])
                    x_picture.append(zz)
                    Y_picture.append(excel_data.iloc[zz-2, 1])

            T = cishu_2 - cishu_1 + 1
            excel_data.iloc[pianduangeshu-1, 15]=T
            Ti=0
            Ta=0
            Td=0
            s=0
            v=[]
            a=[]
            amax=[]
            amin=[]
            for z in range(cishu_1,cishu_2):
                s=excel_data.iloc[z , 1]+s
                v.append(excel_data.iloc[z , 1])
                a.append(excel_data.iloc[z , 14])
                if excel_data.iloc[z , 14]>0.1:
                    amax.append(excel_data.iloc[z , 14])
                if excel_data.iloc[z , 14]<-0.1:
                    amin.append(excel_data.iloc[z , 14])
                if excel_data.iloc[z, 1]==0:
                    Ti=Ti+1
                if excel_data.iloc[z, 14]>0.1:
                    Ta = Ta + 1
                if excel_data.iloc[z, 14]<-0.1:
                    Td = Td + 1
            if Td==0:
                Td=1
            if Ta==0:
                Ta=1
            excel_data.iloc[pianduangeshu - 1, 16] = Ti
            excel_data.iloc[pianduangeshu - 1, 17] = Ta
            excel_data.iloc[pianduangeshu - 1, 18] = Td
            excel_data.iloc[pianduangeshu - 1, 19] = T-Ti-Ta-Td
            Te=T-Ti-Ta-Td
            excel_data.iloc[pianduangeshu - 1, 20] = s
            excel_data.iloc[pianduangeshu - 1, 21] =max(v)
            Vmax=max(v)
            Vm = s/T
            Vmr=s / (T-Ti)
            excel_data.iloc[pianduangeshu - 1, 22] = Vm
            excel_data.iloc[pianduangeshu - 1, 23] = Vmr
            Vs=sum(pow(v - Vm, 2)) / (T - 1)
            excel_data.iloc[pianduangeshu - 1, 24]=Vs
            #print("a",a)
            Amax=max(a)
            Am=sum(amax) / Ta
            Dmax=min(a)
            Dmin=sum(amin) / Td
            excel_data.iloc[pianduangeshu - 1, 25]=Amax
            excel_data.iloc[pianduangeshu - 1, 26] = Am
            excel_data.iloc[pianduangeshu - 1, 27] =Dmax
            excel_data.iloc[pianduangeshu - 1, 28] = Dmin
            a_2=[]
            for xx in a:
                a_2.append(pow(xx, 2))
            As=pow(sum(a_2)/(T-1),1/2)
            excel_data.iloc[pianduangeshu - 1, 29] = As
            Pi=Ti/T
            Pa=Ta/T
            Pd=Td/T
            Pe=1-Pi-Pa-Pd
            excel_data.iloc[pianduangeshu - 1, 30] =Pi
            excel_data.iloc[pianduangeshu - 1, 31] =Pa
            excel_data.iloc[pianduangeshu - 1, 32] =Pd
            excel_data.iloc[pianduangeshu - 1, 33] =Pe

            cishu_1=cishu_2
            if pianduangeshu==136 or pianduangeshu==139 or pianduangeshu== 188 or pianduangeshu== 219 or pianduangeshu== 122 or pianduangeshu ==111 or pianduangeshu==347 or pianduangeshu==190 or pianduangeshu== 140 or pianduangeshu==145 or pianduangeshu==146 or pianduangeshu==147 or pianduangeshu==182:
                T_l.append(T)
                Ti_l.append(Ti)
                Ta_l.append(Ta)
                Td_l.append(Td)
                Te_l.append(Te)
                S_l.append(s)
                Vmax_l.append(Vmax)
                Vm_l.append(Vm)
                Vmr_l.append(Vmr)
                Vs_l.append(Vs)
                Amax_l.append(Amax)
                Am_l.append(Am)
                Dmax_l.append(Dmax)
                Dm_l.append(Dmin)
                As_l.append(As)
                Pi_l.append(Pi)
                Pa_l.append(Pa)
                Pd_l.append(Pd)
                Pe_l.append(Pe)

    cishu = cishu + 1
    key = key+1
    key1 = key1 + 1
T_11=sum(T_l)/14
Ti_l1=sum(Ti_l)/14
Ta_l1=sum(Ta_l)/14
Td_l1=sum(Td_l)/14
Te_l1=sum(Te_l)/14
S_l1=sum(S_l)/14
Vmax_l1=sum(Vmax_l)/14
Vm_l1=sum(Vm_l)/14
Vmr_l1=sum(Vmr_l)/14
Vs_l1=sum(Vs_l)/14
Amax_l1=sum(Amax_l)/14
Am_l1=sum(Am_l)/14
Dmax_l1=sum(Dmax_l)/14
Dm_l1=sum(Dm_l)/14
As_l1=sum(As_l)/14
Pi_l1=sum(Pi_l)/14
Pa_l1=sum(Pa_l)/14
Pd_l1=sum(Pd_l)/14
Pe_l1=sum(Pe_l)/14
print("T_last:",T_11)
print("Ti_last:",Ti_l1)
print("Ta_last:",Ta_l1)
print("Td_last:",Td_l1)
print("Te_last:",Te_l1)
print("S_last:",S_l1)
print("Vmax_last:",Vmax_l1)
print("Vm_last:",Vm_l1)
print("Vmr_last:",Vmr_l1)
print("Vs_last:",Vs_l1)
print("Amax_last:",Amax_l1)
print("Am_last:",Am_l1)
print("Dmax_last:",Dmax_l1)
print("Dm_last:",Dm_l1)
print("As_last:",As_l1)
print("Pi_last:",Pi_l1)
print("Pa_last:",Pa_l1)
print("Pd_last:",Pd_l1)
print("Pe_last:",Pe_l1)
xxxx=[]
for x in range(len(x_picture)):
    xxxx.append(x)
plt.plot(xxxx, Y_picture, linestyle='dashed', linewidth=0.5, color='red' )
print(len(x_picture))
T_last=len(x_picture)
Ti_last =0
for i in v_last:
    if i==0:
        Ti_last=Ti_last+1
Ta_last=0
Td_last=0
Te_last=0
for i in a_last:
    if i >0.1 :
        Ta_last=Ta_last+1
    if i<-0.1:
        Td_last=Td_last+1
Te_last=T_last-Ta_last-Td_last-Ti_last
S_last=sum(v_last)
Vmax_last=max(v_last)
Vm_last=S_last/T_last
Vmr_last=S_last/(T_last-Ti_last)
Vs_last=0
iiiii=[]
for i in v_last:
    iiiii.append(pow((i-Vm_last),2))
Vs_last=pow((sum(iiiii)/(T_last-1)),0.5)
Amax_last=max(a_last)
Am_last=0
Dm_last=0
for i in a_last:
    if i >0.1:
        Am_last=Am_last+i
    if i <-0.1:
        Dm_last=Dm_last+i
Am_last=Am_last/Ta_last
Dm_last=Dm_last/Td_last
Dmax_last=abs(min(a_last))
aaaa=[]
for i in a_last:
    aaaa.append(pow(i,2))
As_last=pow(sum(aaaa)/T_last,0.5)
Pi_last=Ti_last/T_last
Pa_last=Ta_last/T_last
Pd_last=Td_last/T_last
Pe_last=1-Pi_last-Pa_last-Pd_last
print("T_last:",T_last)
print("Ti_last:",Ti_last)
print("Ta_last:",Ta_last)
print("Td_last:",Td_last)
print("Te_last:",Te_last)
print("S_last:",S_last)
print("Vmax_last:",Vmax_last)
print("Vm_last:",Vm_last)
print("Vmr_last:",Vmr_last)
print("Vs_last:",Vs_last)
print("Amax_last:",Amax_last)
print("Am_last:",Am_last)
print("Dmax_last:",Dmax_last)
print("Dm_last:",Dm_last)
print("As_last:",As_last)
print("Pi_last:",Pi_last)
print("Pa_last:",Pa_last)
print("Pd_last:",Pd_last)
print("Pe_last:",Pe_last)

plt.xlabel('value of Time')
plt.ylabel('value of Speed')
plt.show()
DataFrame(excel_data).to_excel("D:/stu/2019年中国研究生数学建模竞赛赛题 (2)/2019年中国研究生数学建模竞赛D题/原始数据/文件2.xlsx", sheet_name='Sheet1', index=False, header=True)
瀑听石
关注
  • 3
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
“华为杯”研究生数学建模竞赛2019年-【华为杯】D题：基于随机搜索和聚类分析以及自编码器再优化的汽车行驶工况构建研究（附优秀论文及Python代码）
getusushu的博客
07-21 347
汽车行驶工况构建的核心在于建立的代表性行驶工况能否反映实际行驶工况，对于实际行驶工况曲线的拟合精度要高。国内外汽车行驶工况的构建方法可以概括为两种方法一种是以全部的预处理后的采集数据为基础，将全部的行驶状态看作一个连续的过程，采用统计学方法分析采集数据表现出来的各种特征，根据采集数据的路段道路等级对其进行分类，计算每个道路等级的运行时间频率，再根据各个道路相应的频率来构建汽车行驶工况曲线，这种方法的计算量较大，且数据间存在较高的相关性会导致数据冗余，不仅造成计算复杂，同时在。
2019年华为杯数学建模赛题.rar
09-24
内含2019年华为杯数学建模比赛全部试题
2019年MathorCup高校数学建模挑战赛D题
04-13
2019年MathorCup高校数学建模挑战赛D题 2019年第九届MathorCup高校数学建模挑战赛 竞赛信息 竞赛简介 为了培养学生的创新意识及运用数学方法和计算机技术解决实际问题的能力，中国优选法统筹法与经济数学研究会决定主办2019年第九届MathorCup高校数学建模挑战赛，欢迎各高等院校按照竞赛章程及有关规定组织同学报名参赛。 组织机构 主办单位：中国优选法统筹法与经济数学研究会 【中国优选法统筹法与经济数学研究会是在中国科学技术协会直接领导下的学术性社会团体，是国家一级学会。学会由华罗庚教授于1981年发起成立，至今成立了评价方法与应用、项目管理、计算机模拟、统筹、管理决策与信息系统、工业工程、高等教育管理、数学教育、经济数学与管理数学、应急管理、灰色系统研究，复杂系统研究等十余个专业分会】 竞赛时间 报名时间：即日起至2019年 4 月 10日 12:00 竞赛时间：2019年4 月 11 日08:00至2019年 4 月 15 日08:00 参赛对象 普通高校全日制在校生（研究生、本科生、专科生）以队为单位参赛，每队不超过3人，不允许跨校组队参赛。 参赛费用 每支队伍需缴纳200元的报名费用。 奖项设置 参赛队伍：全国一等奖（约5%）、全国二等奖（约15%）、全国三等奖（约30%），从一等奖队伍中经过决赛答辩决出4支队伍获得“MathorCup”荣誉奖杯； 组织单位：优秀组织单位、优秀组织社团、优秀组织个人； 其它奖励政策：参见《 MathorCup高校数学建模挑战赛奖励细则》（ 可从官方主页下载）。
2021华为杯研究生数学建模D题.zip
09-23
2021华为杯研究生数学建模D题.zip
2019华为杯研究生数学建模大赛F题.zip
09-23
2019华为杯研究生数学建模大赛F题.zip
2021年华为杯研究生数学建模竞赛D题解答.zip
10-26
* 第一问采用随机森林+相关性分析筛选20个变量 * 第二问采用决策树回归、线性回归、梯度提升向量机、随机 森林回归、多层次感知机回归、XGBoost 回归和LightGBM 模型对生物活性预测。最终得出LightGBM 模型的效果比较好 * 第三问采用多层感知机(MLP)对化合物的 ADMET 性质进行预测。训练集采用90%的样本，测试集采用10%的样本。五种性质的平均准确率为90.5% * 第四问采用改进型贪心调优
2019年华为杯全国研究生数学建模大赛D题.zip
最新发布
11-07
数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等 数学建模大赛参赛作品，供参赛人员学习参考，含论文、设计文档、源代码等
2019年第十六届华为杯研究生数学建模竞赛完整题目(A,B,C,D,E,F)内含附件.zip
05-30
2019年第十六届华为杯数学建模竞赛完整题目(A,B,C,D,E,F)，内含附件。参考每年竞赛题目，赛前练习，扩展建模思路
2019年华为杯数学建模大赛D题画汽车行驶路径
qq_38883271的博客
09-24 2526
程序需要用到python的四个库，分别是folium、numpy、xlrd和os。我用的是python2.7版本，只有os是自带的，剩下三个库都需要用pip安装。程序的大致思路就是，先读入经纬度的excel表格，再将其转化成矩阵，再利用folium库中的函数在地图上绘制出路径。 folium库能够在Leaflet地图上将数据可视化，Leaflet是一个Javascript库中的开源地图...
第十五届“华为杯”中国研究生数学建模竞赛—D题
04-16
第十五届“华为杯”中国研究生数学建模竞赛—D题，原题
2019研究生华为杯数学建模比赛题目.zip
08-30
2019研究生华为杯数学建模比赛题目，2019研究生华为杯数学建模比赛题目，2019研究生华为杯数学建模比赛题目，2019研究生华为杯数学建模比赛题目
2019数模国赛D题.rar_2019中国研究生数学建模竞赛_2019国赛D_D题二等奖_Matlab代码_airplaneay
07-15
此代码运行简单，注释详细，结果全面。可解决2019华为杯研究生数模D题的全部三个问题，供想要参赛的同学参考。
“华为杯”第十四届中国研究生 数学建模竞赛-D题-基于监控视频的前景目标提取（荣获三等奖）
02-24
“华为杯”第十四届中国研究生 数学建模竞赛-D题-基于监控视频的前景目标提取（荣获三等奖）
研究生数学建模大赛常用方法代码
09-22
该压缩包整理了数学建模大赛常用的11种方法，包括 层次分析法，k-means，迪杰斯特拉，退火算法，弗洛伊德，灰色预测，种群竞争等方法。
2019数学建模A题高压油管
09-21
三个问题的代码，分别把problem1，problem2，problem3文件夹复制到matlab存放代码的文件夹里面，然后分别运行main函数就可以得到每一个问题的结果了，注释里面有我调试的答案
2023 研究生数学建模竞赛（A题）建模秘籍&文章代码思路大全
数学建模小秘籍的博客
09-22 268
也就是说,当两个AP的传输时间上存在交叠时,不会视为碰撞时隙,而是认为都是成功的传输。总体思路是建立马尔可夫链模型,计算节点发送概率和碰撞概率,根据时隙类型计算吞吐量。根据问题描述,当仅有一个AP发送数据时,即使没有邻区BSS干扰,由于信道质量变化也会导致一定概率Pe的包丢失。所以在计算平均时隙长度时,并发传输的情况可以视为成功传输时隙,不需要计算碰撞时隙的长度。将三种时隙的长度与对应的概率相乘,可以得到整体网络的平均时隙长度。可以统计到,交叠发生的概率为τ^2,其中τ是节点的发送概率。
【数学建模】常用模型算法及MATLAB代码汇总
热门推荐
360°顺滑
06-07 5万+
小白也能看懂的常用模型算法和 MATLAB 代码。
2019第九届MathorCup数学建模
Hk_Mayfly的博客
04-27 1万+
 题目下载：https://www.lanzous.com/i3taz2j     总共四个问题 问题1 首先附件一中的数据，拿到后肯定感觉棘手。我们的处理方法： 在下面缺失数据的地方我们都认为是问题3中的预测数据 剔除数据中的不规范数据（格式错误） 然后利用自己讨论收得率公式计算收得率。计算出来的收得率可能大于1，认为可能是钢水中存在钢渣，钢渣发生氧化分解产生C...
数学建模竞赛常用代码总结-Python&Matlab
aobulaien001的博客
09-07 4361
数学建模过程中有许多可复用的基础代码，在此对 python 以及 MATLAB 中常用代码进行简单总结，该总结会进行实时更新。一、文件读取文件后缀名（扩展名）并不是必须的，其作用主要一方面是提示系统是用什么软件打开，另一方面提示文件内容格式。如.txt, .csv, .tsv 文件均为纯文本文件，只是 .csv, .tsv 说明了数据的分割方式分别为, 与 \t。
2023年华为杯研究生数学建模D题思路
09-25
华为杯研究生数学建模竞赛的D题要求预测某区域在2021年至2060年期间的人口、经济（GDP）和能源消费量的变化。为了完成这个任务，你可以采用以下步骤： 1. 收集历史数据：获取该区域在过去几年的人口、经济和能源消费量的数据。这些数据可以来自于官方统计机构、研究机构或者公开的数据集。 2. 数据分析：对收集到的数据进行分析，了解各指标的现状和影响因素。可以使用多元线性回归、主成分分析等方法，建立各指标之间的数学关系模型。 3. 经济预测：针对经济（GDP）的预测，可以采用时间序列分析、多元回归分析等方法。结合国家宏观经济政策、全球经济形势等因素，预测该区域未来的经济发展趋势。 4. 人口预测：人口的变化受到多种因素的影响，包括出生率、死亡率、迁移率等。可以利用时间序列分析和人口统计模型，结合历史数据和相关因素，预测该区域的人口变化。 5. 能源消费量预测：能源消费量的预测可以通过建立能源消费与经济增长的数学模型来实现。可以使用多元回归分析等方法，结合历史数据和相关因素，预测未来能源消费的变化趋势。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值