Hinterfragen Sie Ideen
Die Wettbewerbsfragen werden aktualisiert, sobald sie veröffentlicht werden. Folgen Sie Digital Analog Kitty: https://blog.csdn.net/alionCUMT?spm=1011.2266.3001.5343
Vollständiger Code
Die Wettbewerbsfragen werden aktualisiert, sobald sie veröffentlicht werden. Folgen Sie Digital Analog Kitty: https://blog.csdn.net/alionCUMT?spm=1011.2266.3001.5343
Wettbewerbsinformationen
Der 13. Asia-Pacific College Student Mathematical Modeling Competition im Jahr 2023 wird von der Beijing Image and Graphics Society ausgerichtet und vom Organisationskomitee des Asia-Pacific College Student Mathematical Modelling Competition organisiert. Der Wettbewerb richtet sich nach der Wettbewerbscharta und den einschlägigen Vorschriften. Hochschulen und Universitäten sind herzlich willkommen, Studierende für die Teilnahme am Wettbewerb zu organisieren.
Am 12. Wettbewerb für mathematische Modellierung von Hochschulstudenten im asiatisch-pazifischen Raum im Jahr 2022 werden 9.700 Teams aus der ganzen Welt aus 969 Universitäten teilnehmen und mehr als 27.000 Studierende aktiv teilnehmen. Zu den teilnehmenden Universitäten gehören 39 inländische 985 Universitäten und 114.211 Universitäten, darunter die Peking-Universität, die Tsinghua-Universität, die Zhejiang-Universität, die Tongji-Universität, die Shanghai Jiao Tong-Universität, die Fudan-Universität, die Sichuan-Universität, die Technische Universität Dalian usw. Darüber hinaus gibt es neben Universitäten auf dem chinesischen Festland auch die University of California, Berkeley, die Johns Hopkins University und die New York University aus den Vereinigten Staaten; die Middlesex University, die University of Oxford, die University of Liverpool, die University of Nottingham und die University of Liverpool of Edinburgh aus dem Vereinigten Königreich; Deutschland RWTH Aachen University und North Hessen University of Applied Sciences; St. Petersburg State University of Architecture and Architecture in Russland; University of Melbourne und University of Sydney in Australien; University of Malaya in Malaysia; Tohoku University in Japan; Pantheon-Assas-Universität in Paris, Frankreich; City University of Macau, Macau University of Science and Technology, Macau Polytechnic und University of Macau in Macau; Beijing Normal University-Hong Kong Baptist University Joint International College, Chinese University of Hong Kong , die Hong Kong University of Science and Technology und die Hong Kong Polytechnic University in Hongkong; außerdem nehmen chinesisch-ausländische Kooperationsuniversitäten wie die University of Nottingham Ningbo, die Shenzhen Moscow State University und die Xi'an Jiaotong-Liverpool University teil .
Derzeit hat der Wettbewerb international großen Einfluss und gilt als einer der Bewertungswettbewerbe unter inländischen Universitäten als Aufwärmwettbewerb für den US-Wettbewerb, Bonuspunkte für Graduiertenstudien, Bonuspunkte für umfassende Beurteilung und innovative Stipendien.
analytischer Hierarchieprozess
Das Problem lässt sich auf die Bestimmung der relativen Bedeutung der untersten Schicht im Verhältnis zur höchsten Schicht (Ziel) reduzieren.
Modelllösungsschritte:
1. 建立模型
2. 构造判断矩阵，两两比较
一致性检验:检查传递性，是否在误差区间
3. 构造每一层层次比较矩阵
4. 求最底层对最高层权重。
Prämisse: Die Konstruktion der Beurteilungsmatrix ist vernünftig
Sie können Teilprobleme lösen, anstatt den gesamten analytischen Hierarchieprozess zu verwenden.
Konsistenztestcode: Hierarchische Vergleichsmatrix eingeben und Gewichte und Ergebnisse des Konsistenztests ausgeben gleichzeitig
disp('请输入判断矩阵A(n阶)');
A=input('A=');
[n,n]=size(A);
x=ones(n,100);
y=ones(n,100);
m=zeros(1,100);
m(1)=max(x(:,1));
y(:,1)=x(:,1);
x(:,2)=A*y(:,1);
m(2)=max(x(:,2));
y(:,2)=x(:,2)/m(2);
p=0.0001;i=2;k=abs(m(2)-m(1));
while k>p
i=i+1;
x(:,i)=A*y(:,i-1);
m(i)=max(x(:,i));
y(:,i)=x(:,i)/m(i);
k=abs(m(i)-m(i-1));
end
a=sum(y(:,i));
w=y(:,i)/a;
t=m(i);
disp(w);
%以下是一致性检验
CI=(t-n)/(n-1);RI=[0 0 0.52 0.89 1.12 1.26 1.36 1.41 1.46 1.49 1.52 1.54 1.56 1.58 1.59];
CR=CI/RI(n);
if CR<0.10
disp('此矩阵的一致性可以接受!');
disp('CI=');disp(CI);
disp('CR=');disp(CR);
end
Entscheidungsmodell mit mehreren Attributen
Methoden zum Sortieren von Lösungen anhand vorhandener Entscheidungsinformationen
Verwendung von WAA: Operatorberechnung des gewichteten arithmetischen Durchschnitts
Schritt 1: Normalisierung der Attributwerte (alle haben feste Formeln):
- Leistungstyp
- Kostenart
- Fester Typ
- Bezirkstyp
…
Schritt 2:(Analysemethode auf gleicher Ebene) Erstellen Sie eine Vergleichsmatrix: Berechnen Sie die Gewichtung jedes Attributs
Schritt 3:Normalisiert durchAttributgewichtx Die verarbeiteten data kann die Gewichtung jedes Plans ermitteln und einfach die Gewichtung jedes Plans vergleichen.
Graue Prognose
Eine Methode, Vorhersagen mit einer kleinen Menge unvollständiger Informationen zu treffen.
GM(1,1)-Vorhersage:
function []=greymodel(y)
% 本程序主要用来计算根据灰色理论建立的模型的预测值。
% 应用的数学模型是 GM(1,1)。
% 原始数据的处理方法是一次累加法。
y=input('请输入数据 ');
n=length(y);
yy=ones(n,1);
yy(1)=y(1);
for i=2:n
yy(i)=yy(i-1)+y(i);
end
B=ones(n-1,2);
for i=1:(n-1)
B(i,1)=-(yy(i)+yy(i+1))/2;
B(i,2)=1;
end
BT=B';
for j=1:n-1
YN(j)=y(j+1);
end
YN=YN';
A=inv(BT*B)*BT*YN;
a=A(1);
u=A(2);
t=u/a;
i=1:n+2;
yys(i+1)=(y(1)-t).*exp(-a.*i)+t;
yys(1)=y(1);
for j=n+2:-1:2
ys(j)=yys(j)-yys(j-1);
end
x=1:n;
xs=2:n+2;
yn=ys(2:n+2);
plot(x,y,'^r',xs,yn,'*-b');
det=0;
sum1=0;
sumpe=0;
for i=1:n
sumpe=sumpe+y(i);
end
pe=sumpe/n;
for i=1:n;
sum1=sum1+(y(i)-pe).^2;
end
s1=sqrt(sum1/n);
sumce=0;
for i=2:n
sumce=sumce+(y(i)-yn(i));
end
ce=sumce/(n-1);
sum2=0;
for i=2:n;
sum2=sum2+(y(i)-yn(i)-ce).^2;
end
s2=sqrt(sum2/(n-1));
c=(s2)/(s1);
disp(['后验差比值为：',num2str(c)]);
if c<0.35
disp('系统预测精度好')
else if c<0.5
disp('系统预测精度合格')
else if c<0.65
disp('系统预测精度勉强')
else
disp('系统预测精度不合格')
end
end
end
disp(['下个拟合值为 ',num2str(ys(n+1))]);
disp(['再下个拟合值为',num2str(ys(n+2))]);
Dijkstra-Algorithmus
Kann den kürzesten Weg vom Startpunkt zu allen anderen Eckpunkten finden
Hinweis: Die Gewichtung in der ersten Datei ist die gewichtete Adjazenzmatrix
weight= [0 2 8 1 Inf Inf Inf Inf Inf Inf Inf;
2 0 6 Inf 1 Inf Inf Inf Inf Inf Inf;
8 6 0 7 5 1 2 Inf Inf Inf Inf;
1 Inf 7 0 Inf Inf 9 Inf Inf Inf Inf;
Inf 1 5 Inf 0 3 Inf 2 9 Inf Inf;
Inf Inf 1 Inf 3 0 4 Inf 6 Inf Inf;
Inf Inf 2 9 Inf 4 0 Inf 3 1 Inf;
Inf Inf Inf Inf 2 Inf Inf 0 7 Inf 9;
Inf Inf Inf Inf 9 6 3 7 0 1 2;
Inf Inf Inf Inf Inf Inf 1 Inf 1 0 4;
Inf Inf Inf Inf Inf Inf Inf 9 2 4 0;];
[dis, path]=dijkstra(weight,1, 11)
dijkstra.m
function [min,path]=dijkstra(w,start,terminal)
n=size(w,1); label(start)=0; f(start)=start;
for i=1:n
if i~=start
label(i)=inf;
end, end
s(1)=start; u=start;
while length(s)<n
for i=1:n
ins=0;
for j=1:length(s)
if i==s(j)
ins=1;
end,
end
if ins==0
v=i;
if label(v)>(label(u)+w(u,v))
label(v)=(label(u)+w(u,v));
f(v)=u;
end,
end,
end
v1=0;
k=inf;
for i=1:n
ins=0;
for j=1:length(s)
if i==s(j)
ins=1;
end,
end
if ins==0
v=i;
if k>label(v)
k=label(v); v1=v;
end,
end,
end
s(length(s)+1)=v1;
u=v1;
end
min=label(terminal); path(1)=terminal;
i=1;
while path(i)~=start
path(i+1)=f(path(i));
i=i+1 ;
end
path(i)=start;
L=length(path);
path=path(L:-1:1);
Floyd-Algorithmus
Finden Sie den kürzesten Weg vom Startpunkt zu allen anderen Eckpunkten und geben Sie die Pfadmatrix aus. Sie müssen sie manuell betrachten. Wie die Ergebnisse des Dijstra-Algorithmus können die beiden Algorithmen gleichzeitig analysiert werden, um sich gegenseitig zu bestätigen.
a= [ 0,50,inf,40,25,10;
50,0,15,20,inf,25;
inf,15,0,10,20,inf;
40,20,10,0,10,25;
25,inf,20,10,0,55;
10,25,inf,25,55,0];
[D, path]=floyd(a)
function [D,path,min1,path1]=floyd(a,start,terminal)
D=a;n=size(D,1);path=zeros(n,n);
for i=1:n
for j=1:n
if D(i,j)~=inf
path(i,j)=j;
end,
end,
end
for k=1:n
for i=1:n
for j=1:n
if D(i,k)+D(k,j)<D(i,j)
D(i,j)=D(i,k)+D(k,j);
path(i,j)=path(i,k);
end,
end,
end,
end
if nargin==3
min1=D(start,terminal);
m(1)=start;
i=1;
path1=[ ];
while path(m(i),terminal)~=terminal
k=i+1;
m(k)=path(m(i),terminal);
i=i+1;
end
m(i+1)=terminal;
path1=m;
end
Simulierter Glühalgorithmus
Imitiert das Glühphänomen in der Natur. In diesem Abschnitt wird die Lösung des TSP-Problems erläutert
TSP-Themen umfassen:Straßentransport, Logistikplanung, Internet-Einrichtungsknoten
function [ newpath , position ] = swap( oldpath , number )
% 对 oldpath 进 行 互 换 操 作
% number 为 产 生 的 新 路 径 的 个 数
% position 为 对 应 newpath 互 换 的 位 置
m = length( oldpath ) ; % 城 市 的 个 数
newpath = zeros( number , m ) ;
position = sort( randi( m , number , 2 ) , 2 ); % 随 机 产 生 交 换 的 位 置
for i = 1 : number
newpath( i , : ) = oldpath ;
% 交 换 路 径 中 选 中 的 城 市
newpath( i , position( i , 1 ) ) = oldpath( position( i , 2 ) ) ;
newpath( i , position( i , 2 ) ) = oldpath( position( i , 1 ) ) ;
end
function [ objval ] = pathfare( fare , path )
% 计 算 路 径 path 的 代 价 objval
% path 为 1 到 n 的 排 列 ，代 表 城 市 的 访 问 顺 序 ；
% fare 为 代 价 矩 阵 ， 且 为 方 阵 。
[ m , n ] = size( path ) ;
objval = zeros( 1 , m ) ;
for i = 1 : m
for j = 2 : n
objval( i ) = objval( i ) + fare( path( i , j - 1 ) , path( i , j ) ) ;
end
objval( i ) = objval( i ) + fare( path( i , n ) , path( i , 1 ) ) ;
end
function [ fare ] = distance( coord )
% 根 据 各 城 市 的 距 离 坐 标 求 相 互 之 间 的 距 离
% fare 为 各 城 市 的 距 离 ， coord 为 各 城 市 的 坐 标
[ v , m ] = size( coord ) ; % m 为 城 市 的 个 数
fare = zeros( m ) ;
for i = 1 : m % 外 层 为 行
for j = i : m % 内 层 为 列
fare( i , j ) = ( sum( ( coord( : , i ) - coord( : , j ) ) .^ 2 ) ) ^ 0.5 ;
fare( j , i ) = fare( i , j ) ; % 距 离 矩 阵 对 称
end
end
function [ ] = myplot( path , coord , pathfar )
% 做 出 路 径 的 图 形
% path 为 要 做 图 的 路 径 ，coord 为 各 个 城 市 的 坐 标
% pathfar 为 路 径 path 对 应 的 费 用
len = length( path ) ;
clf ;
hold on ;
title( [ '近似最短路径如下，路程为' , num2str( pathfar ) ] ) ;
plot( coord( 1 , : ) , coord( 2 , : ) , 'ok');
pause( 0.4 ) ;
for ii = 2 : len
plot( coord( 1 , path( [ ii - 1 , ii ] ) ) , coord( 2 , path( [ ii - 1 , ii ] ) ) , '-b');
x = sum( coord( 1 , path( [ ii - 1 , ii ] ) ) ) / 2 ;
y = sum( coord( 2 , path( [ ii - 1 , ii ] ) ) ) / 2 ;
text( x , y , [ '(' , num2str( ii - 1 ) , ')' ] ) ;
pause( 0.4 ) ;
end
plot( coord( 1 , path( [ 1 , len ] ) ) , coord( 2 , path( [ 1 , len ] ) ) , '-b' ) ;
x = sum( coord( 1 , path( [ 1 , len ] ) ) ) / 2 ;
y = sum( coord( 2 , path( [ 1 , len ] ) ) ) / 2 ;
text( x , y , [ '(' , num2str( len ) , ')' ] ) ;
pause( 0.4 ) ;
hold off ;
clear;
% 程 序 参 数 设 定
Coord = ... % 城 市 的 坐 标 Coordinates 第一列代表第一个城市的x，y坐标，第二列代表第二个城市的x，y坐标...
[ 0.6683 0.6195 0.4 0.2439 0.1707 0.2293 0.5171 0.8732 0.6878 0.8488 ; ...
0.2536 0.2634 0.4439 0.1463 0.2293 0.761 0.9414 0.6536 0.5219 0.3609 ] ;
t0 = 1 ; % 初 温 t0
iLk = 20 ; % 内 循 环 最 大 迭 代 次 数 iLk
oLk = 50 ; % 外 循 环 最 大 迭 代 次 数 oLk
lam = 0.95 ; % λ lambda
istd = 0.001 ; % 若 内 循 环 函 数 值 方 差 小 于 istd 则 停 止
ostd = 0.001 ; % 若 外 循 环 函 数 值 方 差 小 于 ostd 则 停 止
ilen = 5 ; % 内 循 环 保 存 的 目 标 函 数 值 个 数
olen = 5 ; % 外 循 环 保 存 的 目 标 函 数 值 个 数
% 程 序 主 体
m = length( Coord ) ; % 城 市 的 个 数 m
fare = distance( Coord ) ; % 路 径 费 用 fare
path = 1 : m ; % 初 始 路 径 path
pathfar = pathfare( fare , path ) ; % 路 径 费 用 path fare
ores = zeros( 1 , olen ) ; % 外 循 环 保 存 的 目 标 函 数 值
e0 = pathfar ; % 能 量 初 值 e0
t = t0 ; % 温 度 t
for out = 1 : oLk % 外 循 环 模 拟 退 火 过 程
ires = zeros( 1 , ilen ) ; % 内 循 环 保 存 的 目 标 函 数 值
for in = 1 : iLk % 内 循 环 模 拟 热 平 衡 过 程
[ newpath , v ] = swap( path , 1 ) ; % 产 生 新 状 态
e1 = pathfare( fare , newpath ) ; % 新 状 态 能 量
% Metropolis 抽 样 稳 定 准 则
r = min( 1 , exp( - ( e1 - e0 ) / t ) ) ;
if rand < r
path = newpath ; % 更 新 最 佳 状 态
e0 = e1 ;
end
ires = [ ires( 2 : end ) e0 ] ; % 保 存 新 状 态 能 量
% 内 循 环 终 止 准 则 ：连 续 ilen 个 状 态 能 量 波 动 小 于 istd
if std( ires , 1 ) < istd
break ;
end
end
ores = [ ores( 2 : end ) e0 ] ; % 保 存 新 状 态 能 量
% 外 循 环 终 止 准 则 ：连 续 olen 个 状 态 能 量 波 动 小 于 ostd
if std( ores , 1 ) < ostd
break ;
end
t = lam * t ;
end
pathfar = e0 ;
% 输 入 结 果
fprintf( '近似最优路径为：\n ' )
Bevölkerungswettbewerbsmodell
Um den Wettbewerb zwischen zwei Populationen zu simulieren, ändern Sie einfach die Anfangsparameter.
Anwendung: Verkauf ähnlicher Produkte durch verschiedene Unternehmen...
fun.m:
function dx=fun(t,x,r1,r2,n1,n2,s1,s2)
r1=1;
r2=1;
n1=100;
n2=100;
s1=0.5;
s2=2;
dx=[r1*x(1)*(1-x(1)/n1-s1*x(2)/n2);r2*x(2)*(1-s2*x(1)/n1-x(2)/n2)];
p3.m:
h=0.1;%所取时间点间隔
ts=[0:h:30];%时间区间
x0=[10,10];%初始条件
opt=odeset('reltol',1e-6,'abstol',1e-9);%相对误差1e-6，绝对误差1e-9
[t,x]=ode45(@fun,ts,x0,opt);%使用5级4阶龙格—库塔公式计算
plot(t,x(:,1),'r',t,x(:,2),'b','LineWidth',2),grid;
pause;
plot(x(:,1),x(:,2),'LineWidth',2),grid %作相轨线
Warteschlangentheorie
Lösen Sie die Beziehung zwischen der Anzahl der Anrufleitungen und den Anrufen der Telefonbenutzer
Modell enthält:
-
Kundeneingabeprozess
-
Warteschlangenstruktur und Warteschlangenregeln
-
Serviceorganisationen und Serviceregeln
-
Ankunftsintervall und Servicezeitverteilung
Systemstatusparameter:
-
N(t) Die Gesamtzahl der Kunden zum Zeitpunkt t
-
Übergangswahrscheinlichkeit P(t) Die Wahrscheinlichkeit des Systemzustands N(t)=n zum Zeitpunkt t
-
Steady-State-Wahrscheinlichkeit P=lim P(t)
Parameter der Systembetriebsanzeige:
-
Anzahl der Kunden und Anzahl der Kunden, die darauf warten, bedient zu werden
-
GesamtzeitundWarteschlangenzeit
-
Hauptverkehrszeit und Leistungsvolumen während der Hauptverkehrszeit
-
Verlustrate
-
Serviceintensität
klassisches Modell
Berechnen Sie durch Eingabe von mu und Lambda Lq, Ls, Ws, Wq.
M/M/1-Warteschlangensystem
Für einen Service Desk erfüllt die Kundenquelle die Poisson-Verteilung, ein einzelnes Team, einen einzelnen Service Desk, „First In“, „First Out“ und zufällige Servicezeit.
M/M/S-Warteschlangensystem
Es gibt S-Servicedesks, jeder Servicedesk ist unabhängig voneinander und die anderen sind die gleichen wie oben.
Code
M/M/1-Prozesssimulationscode
Simulationszeit ändern,mu,
Lambda-> ändern Es gibt mehr Serviceschalter, weniger Leute kommen an einen bestimmten Schalter und der Druck wird verringert.
Diese Codezeichenfolge generiert ein simuliertes Bild des Warteschlangenvorgangs
clear
clc
%*****************************************
%初始化顾客源
%*****************************************
%总仿真时间
Total_time = 10;
%队列最大长度
N = 10000000000;
%到达率与服务率
lambda = 10;
mu = 6;
%平均到达时间与平均服务时间
arr_mean = 1/lambda;
ser_mean = 1/mu;
arr_num = round(Total_time*lambda*2);
events = [];
%按负指数分布产生各顾客达到时间间隔
events(1,:) = exprnd(arr_mean,1,arr_num);
%各顾客的到达时刻等于时间间隔的累积和
events(1,:) = cumsum(events(1,:));
%按负指数分布产生各顾客服务时间
events(2,:) = exprnd(ser_mean,1,arr_num);
%计算仿真顾客个数，即到达时刻在仿真时间内的顾客数
len_sim = sum(events(1,:)<= Total_time);
%*****************************************
%计算第 1个顾客的信息
%*****************************************
%第 1个顾客进入系统后直接接受服务，无需等待
events(3,1) = 0;
%其离开时刻等于其到达时刻与服务时间之和
events(4,1) = events(1,1)+events(2,1);
%其肯定被系统接纳，此时系统内共有
%1个顾客，故标志位置1
events(5,1) = 1;
%其进入系统后，系统内已有成员序号为 1
member = [1];
for i = 2:arr_num
%如果第 i个顾客的到达时间超过了仿真时间，则跳出循环
if events(1,i)>Total_time
break;
else
number = sum(events(4,member) > events(1,i));
%如果系统已满，则系统拒绝第 i个顾客，其标志位置 0
if number >= N+1
events(5,i) = 0;
%如果系统为空，则第 i个顾客直接接受服务
else
if number == 0
%其等待时间为 0
2009.1516
%PROGRAMLANGUAGEPROGRAMLANGUAGE
events(3,i) = 0;
%其离开时刻等于到达时刻与服务时间之和
events(4,i) = events(1,i)+events(2,i);
%其标志位置 1
events(5,i) = 1;
member = [member,i];
%如果系统有顾客正在接受服务，且系统等待队列未满，则 第 i个顾客进入系统
else len_mem = length(member);
%其等待时间等于队列中前一个顾客的离开时刻减去其到 达时刻
events(3,i)=events(4,member(len_mem))-events(1,i);
%其离开时刻等于队列中前一个顾客的离开时刻加上其服
%务时间
events(4,i)=events(4,member(len_mem))+events(2,i);
%标识位表示其进入系统后，系统内共有的顾客数
events(5,i) = number+1;
member = [member,i];
end
end
end
end
%仿真结束时，进入系统的总顾客数
len_mem = length(member);
%*****************************************
%输出结果
%*****************************************
%绘制在仿真时间内，进入系统的所有顾客的到达时刻和离
%开时刻曲线图（stairs：绘制二维阶梯图）
stairs([0 events(1,member)],0:len_mem);
hold on;
stairs([0 events(4,member)],0:len_mem,'.-r');
legend('到达时间 ','离开时间 ');
hold off;
grid on;
%绘制在仿真时间内，进入系统的所有顾客的停留时间和等
%待时间曲线图（plot：绘制二维线性图）
figure;
plot(1:len_mem,events(3,member),'r-*',1: len_mem,events(2,member)+events(3,member),'k-');
legend('等待时间 ','停留时间 ');
grid on;
M/M/S vier Indikatorberechnungscodes
Ändern Sie Mu und Lambda und wandeln Sie sie in die Anzahl der Servicemitarbeiter pro Stunde um.
Diese Codezeichenfolge berechnet die vier Schlüsselindikatoren für M/M/S aus den Eingabeparametern.
s=2;
mu=4;
lambda=3;
ro=lambda/mu;
ros=ro/s;
sum1=0;
for i=0:(s-1)
sum1=sum1+ro.^i/factorial(i);
end
sum2=ro.^s/factorial(s)/(1-ros);
p0=1/(sum1+sum2);
p=ro.^s.*p0/factorial(s)/(1-ros);
Lq=p.*ros/(1-ros);
L=Lq+ro;
W=L/lambda;
Wq=Lq/lambda;
fprintf('排队等待的平均人数为%5.2f人\n',Lq)
fprintf('系统内的平均人数为%5.2f人\n',L)
fprintf('平均逗留时间为%5.2f分钟\n',W*60)
fprintf('平均等待时间为%5.2f分种\n',Wq*60)
lineares Programmiermodell
Eine kleine Frage innerhalb eines größeren mathematischen Modellierungsproblems
Beispielcode:
max=2*x1+3*x2;
x1+2*x2<=8;
4*x1<=16;
4*x2<=12;
Nichtlineare Programmierung und 01-Programmierung
Nichtlinear: Es enthält nichtlineare Komponenten
@gin(x1): Finden Sie die Ganzzahl von x1
Codebeispiel:
Model:
max=98*x1+277*x2-x1*x1-0.3*x1*x2-2*x2*x2;
x1+x2<100;
x1<=2*x2;
@gin(x1);
@gin(x2);
end
01 Planung: Das Problem unbekannter Größen mit den Werten nur 0 und 1 (spiegelt sich in restriktiven Bedingungen wider)
Codebeispiel:
Model:
Min=8*x11+13*x12+18*x13+23*x14+10*x21+14*x22+16*x23+27*x24+2*x31+10*x32+21*x33+26*x34+14*x41+22*x42+26*x43+28*x44;
x11+x12+x13+x14=1;
x21+x22+x23+x24=1;
x31+x32+x33+x34=1;
x41+x42+x43+x44=1;
x11+x21+x31+x41=1;
x12+x22+x32+x42=1;
x13+x23+x33+x43=1;
x14+x24+x34+x44=1;
end
int16
Hauptkomponentenanalyse
Die Bedienung ist etwas verwirrend und ich verstehe sie nicht ganz.
Folgen Sie einfach dem Video zu SPSS-Vorgängen, das einfache Vorgänge in Excel beinhaltet
1.输入数据
2.找到Compent Martix，里面有若干变量F1,F2
3.提取数据到excel
4.将变量Fi的数据除以变量Fi特征值的平方根，算出指标对应的系数，得出新因子Fi与原变量的线性关系
5.以特征值为权重，加权平均写出F表达式
6.写出表达式后，归一化数据，带入表达式，算出最终结果，比较F
Mehrere Variablen ausführenLineare TransformationEine kleinere Anzahl wichtiger Variablen auswählen
Wählen Sie den Eigenwert größer als 1 und berechnen Sie den entsprechenden Indexkoeffizienten.
Nachdem Sie wichtige Variablen ausgewählt haben, können Sie die tatsächliche Bedeutung erraten
Clusteranalyse
Gleiche Vögel scharen sich zusammen, sehen Sie sich das Video für weitere Details an
Schauen Sie sich das Baumdiagramm und das Eiszapfendiagramm an, legen Sie einfach das Diagramm oben und ziehen Sie die Klassifizierungsschlussfolgerung.
Multiple Regressionsanalyse
Verstehen Sie, ob zwei oder mehr Variablen zusammenhängen, sowie die Richtung und Stärke der Korrelation
Zum Beispiel: der Zusammenhang zwischen Einkommensniveau und Bildung, Branche und Art der Arbeit