Analyse des idées de papier Huashu Cup 2022 + code complet (plan d'assemblage du robot sous-marin)

Vous pouvez jeter un oeil à la vidéo d'analyse officielle (tant que cette vidéo est candidate, vous pouvez la regarder gratuitement. Pour ceux qui ne peuvent pas la regarder, j'envisagerai de créer un blog dans quelques jours). , j'ai mis la réponse standard officielle à la fin de ce blog. , pour votre propre référence.
Vidéo d'analyse officielle de la Huashu Cup 2022 de la question B》》》》》》》

Voici une déclaration, je participe à la Huashu Cup avec la question C. La thèse et le code font référence à d'autres, mais c'est bien ce blog que j'ai travaillé si dur pour trier. Je suis aussi un novice, et je Je viens de l'envoyer pour trier. Les idées sont pratiques pour l'auto-apprentissage et ne sont données qu'à titre de référence. Il n'existe pas d'excellent article ou de réponse standard.

Titre complet :
lien : https://pan.baidu.com/s/16E1X35O13NWIij72OClVgQ?pwd=1234
Code d'extraction : 1234

1. Le sujet

2. Analyse du problème

3. Hypothèses du modèle

1. Suffisamment de matériaux pour assembler de petits composants.
2. Pendant le processus de production, la production ne sera pas interrompue en raison de situations inattendues telles que des pannes de courant en usine et des pannes mécaniques.
3. Le flux de capitaux de l'usine est normal et la production ne sera pas affectée en raison du manque de capital.
4. Seul le robot du produit final a une demande externe et les autres composants ne sont pas vendus à l'extérieur.
5. La demande de robots est déterminée conformément au plan et n'est pas affectée par les fluctuations des prix du marché.

4. Description des symboles

symbole	illustrer	unité
ré	journées	ciel
MA1 d , MA2 d , MA3 d … MC3 d	Quantité d'assemblage de widgets au jour j	individuel
SA1 d , SA2 d , SA3 d … SC3 d	Quantité restante de widget au jour j	individuel
MA d , MB d ,MC d	Quantité d'assemblage de gros composants au jour j	individuel
SA d , SB d , SC d	Quantité restante de gros composants au jour j	individuel
DW d	Le nombre de robots demandés le jour j	individuel
MW j	Le nombre de robots assemblés le jour j	individuel
SO d	Le nombre de robots restant le jour j	individuel
T d	Limite totale d'heures de travail le jour j	heures d'ouverture
RA1,RA2,…RB,RC	coût de stockage par unité pour le composant	Yuan
FA1,FA2,…,FB,FC	Coût de préparation de production du composant	Yuan
XW d	0-1 variable indiquant s'il faut produire des robots le jour j	-
R d	Coût des stocks au jour j	Yuan
F d	Coût de préparation de la production au jour j	Yuan
checkDate t	Date de la tième révision	ciel
Tgrand d	Limite totale d'heures de travail le jour j	heures d'ouverture
DWprédire d	Le nombre de robots demandés le jour d'une semaine dans le futur	individuel

5. Établissement et solution du modèle du problème 1

5.1 L'établissement du modèle-problème

5.1.1 Les petits composants assemblent les grands composants

Ici, l'assemblage du grand composant A est pris comme exemple. L'assemblage d'un grand composant A nécessite 6 petits composants A1, 8 petits composants A2 et 2 petits composants A3.

Au jour j, le nombre de petits composants A1 utilisés pour assembler le gros composant A est : le nombre de petits composants assemblés au jour j (le jour courant) MA1 _d et le nombre de petits composants restant au jour j-1 (hier) SA1 _d-1 et, à savoir MA1 _d + SA1 _d-1 . Le nombre de widgets A2 et A3 peut être obtenu de la même manière.

L'assemblage d'un gros composant A nécessite 6 petits composants A1. Si seul A1 est considéré, le nombre maximum de gros composants pouvant être assemblés est de :

$$\left[\begin{array}{c}\frac{MA{1}_{}+SA{1}_{ré-}}{6}\end{array}\right]\text{\hspace{1em}( 1 )}$$

Remarque : Le symbole [ ] ici est arrondi à l'inférieur, c'est-à-dire qu'il prend le plus grand nombre entier plus petit que lui-même.

De même, si seul A2 est considéré, le nombre maximum de grands composants A pouvant être assemblés est :

$$\left[\begin{array}{c}\frac{MA{2}_{}+SA{2}_{ré-}}{8}\end{array}\right]\text{\hspace{1em}( 2 )}$$
Si seul A3 est considéré, le nombre maximum de gros composants A pouvant être assemblés est de :

$$\left[\begin{array}{c}\frac{MA{3}_{}+SA{3}_{ré-}}{2}\end{array}\right]\text{\hspace{1em}( 3 )}$$

Ainsi, le nombre maximum d'assemblages du grand composant A au jour j est de :

$$min\left[\left(\begin{array}{c}\frac{MA{1}_{}+SA{1}_{ré-}}{6},\frac{MA{2}_{}+SA{2}_{ré-}}{8},\frac{MA{3}_{}+SA{3}_{ré-}}{2}\end{array}\right)\right]\text{\hspace{1em}( 4 )}$$

Remarque : il faut arrondir à l'inférieur

Le nombre de robots requis pour chaque jour est différent.Pour répondre à la demande de la commande, lorsque l'usine assemble le gros composant A, il ne doit pas nécessairement être égal à la valeur maximale. Ainsi, au jour j, la quantité d'assemblage du gros composant A doit satisfaire les contraintes suivantes :

$$MA{\_}_{}⩽min\left[\left(\begin{array}{c}\frac{MA{1}_{}+SA{1}_{ré-}}{6},\frac{MA{2}_{}+SA{2}_{ré-}}{8},\frac{MA{3}_{}+SA{3}_{ré-}}{2}\end{array}\right)\right]\text{\hspace{1em}( 5 )}$$

De même, le jour j, la quantité d'assemblage des gros composants B et C doit respecter les contraintes suivantes :

$$M{B}_{}⩽min\left[\left(\begin{array}{c}\frac{Mo{1}_{}+SB{1}_{ré-}}{2},\frac{Mo{2}_{}+SB{2}_{ré-}}{4}\end{array}\right)\right]\text{\hspace{1em}( 6 )}$$

$$M{C}_{}⩽min\left[\left(\begin{array}{c}\frac{CM{1}_{}+SC{1}_{ré-}}{8},\frac{MC{2}_{}+CS{2}_{ré-}}{2},\frac{MC{2}_{}+CS{2}_{ré-}}{12}\end{array}\right)\right]\text{\hspace{1em}( 6 )}$$

5.1.2 Widgets restants

Après avoir assemblé un gros composant avec un petit composant, il peut y avoir des restes du petit composant. Ici, le widget A1 est utilisé comme exemple.
Au jour j, le nombre de widgets restants A1, devra satisfaire, la somme du nombre de widgets assemblés au jour j MA1 _d , et le nombre de widgets restants au jour j-1 SA1 _d-1 , moins la somme du nombre de widgets au jour j j-1 La consommation d'Al. Pour assembler un grand composant A, 6 petits composants A1 sont nécessaires. Par conséquent, la quantité de Al consommée le jour j est de 6 × MA _d . Ainsi, la quantité restante SA1 _d de A1 au jour j est la suivante :

$$SA1\_{}_{}=MA{1}_{}+SA1\_{}_{ré-}-6\ast MA{\_}_{}\text{\hspace{1em}( 7 )}$$

Aujourd'hui - Consommé = Restant
(Assemblé aujourd'hui + Restes d'hier) - Consommé = Restant

Le nombre restant d'autres petites composantes peut être obtenu de la même manière :
$$SA2\_{}_{}=MA{2}_{}+SA2\_{}_{ré-}-8\ast MA{\_}_{}$$
$$SA3\_{}_{}=MA{3}_{}+SA3\_{}_{ré-}-2\ast MA{\_}_{}$$
$$SB{1}_{}=Mo{1}_{}+SB{1}_{ré-}-2\ast M{B}_{}$$
$$SB{2}_{}=MA{1}_{}+SA1\_{}_{ré-}-4\ast M{B}_{}\text{\hspace{1em}( 8 )}$$
$$SC{1}_{}=CM{1}_{}+SC{1}_{ré-}-8\ast M{C}_{}$$
$$CS{2}_{}=MC{2}_{}+CS{2}_{ré-}-2\ast M{C}_{}$$
$$SC{3}_{}=MC{3}_{}+SC{3}_{ré-}-12\ast M{C}_{}$$

5.1.3 Calcul des gros composants restants par la quantité d'assemblage du robot

L'assemblage du robot, c'est-à-dire assembler le robot avec de gros composants, revient à assembler de gros composants avec de petits composants, donc le nombre de robots assemblés le jour j est le suivant :

$$M{F}_{}⩽min\left[\left(\begin{array}{c}\frac{MA{1}_{}+SA{1}_{ré-}}{3},\frac{Mo{2}_{}+SB{2}_{ré-}}{4},\frac{MC{2}_{}+CS{2}_{ré-}}{5}\end{array}\right)\right]\text{\hspace{1em}( 9 )}$$

Parmi eux, MW _d est le nombre de robots assemblés, MA _d est le nombre d'assemblage de gros composants A au jour j, et SA _d-1 est le nombre restant de gros composants A au jour j-1.

Assemblez le robot à partir de gros composants, qui peuvent avoir des restes. Il est calculé de la même manière que le calcul du nombre de widgets restant, comme suit :

$$SA{\_}_{}=MA{\_}_{}+SA{\_}_{ré-}-3\ast M{F}_{}$$
$$S{B}_{}=M{B}_{}+S{B}_{ré-}-4\ast M{F}_{}\text{\hspace{1em}( 10 )}$$
$$SC{\_}_{}=M{C}_{}+SC{\_}_{ré-}-5\ast M{F}_{}$$

5.1.4 Contraintes de quantité d'assemblage de robot

Toutes les commandes de robots acceptées par l'usine doivent être livrées à leur échéance, donc la somme de la quantité d'assemblage MW _j de robots au jour j et de la quantité restante SW _d de robots au jour j-1 doit être supérieure à la quantité demandée DW j le jour _j .
$$M{F}_{}+SW{\_}_{ré-}⩾DW{\_}_{}\text{\hspace{1em}( 12 )}$$

5.1.5 Robot restant

Il peut y avoir des restes après la vente quotidienne de bots à commander. Le SW _d restant du robot au jour j est égal à la somme de la quantité d'assemblage MW _d au jour j et de la quantité restante SW _d-1 au jour j-1 moins la quantité commandée DW _d au jour . lequel est

$$SW{\_}_{}=M{F}_{}+SW{\_}_{ré-}-DW{\_}_{}\text{\hspace{1em}( 12 )}$$

5.1.6 Pas de Stock Pas Restant

Le jour 1 commence sans aucun composant en stock, c'est-à-dire :
$$SA1\_{}_{}=SA2\_{}_{}=SA3\_{}_{}=SB{1}_{}=SB{2}_{}=SC{1}_{}=CS{2}_{}=SC{3}_{}\text{\hspace{1em}( 13 )}$$
$$SA{\_}_{}=S{B}_{}=SC{\_}_{}=0\text{\hspace{1em}( 13 )}$$

Aucun inventaire de composants ne sera laissé après le septième jour, c'est-à-dire

$$SA1\_{}_{}=SA2\_{}_{}=SA3\_{}_{}=SB{1}_{}=SB{2}_{}=SC{1}_{}=CS{2}_{}=SC{3}_{}$$
$$SA{\_}_{}=S{B}_{}=SC{\_}_{}=0\text{\hspace{1em}( 14 )}$$
$$SW{\_}_{}=0$$

5.1.7 Restrictions sur les heures de travail

Il faut 3 heures de travail pour produire 1 pièce de A, 5 heures de travail pour produire 1 pièce de B et 5 heures de travail pour produire 1 pièce de C. Les contraintes suivantes doivent être satisfaites en même temps :

$$3\times MA{\_}_{}+5\times M{B}_{}+5\times M{C}_{}⩽J_{}\text{\hspace{1em}( 15 )}$$

5.1.8 Frais d'inventaire

Lorsqu'un composant est en stock à la fin d'une journée, l'usine doit payer une certaine taxe d'inventaire, qui est proportionnelle à la quantité restante du composant. Ainsi, en fonction de la quantité de composants restante au jour J, on peut exprimer le coût d'inventaire des petits composants, des gros composants et des robots.

$$RpetiteA\_\_{}_{}=RA1\_\times SA1\_{}_{}+RA2\times SA2\_{}_{}+RA3\_\times SA3\_{}_{}$$

$$RpetitB\_\_{}_{}=RB1\times SB{1}_{}+RB2\times SB{2}_{}$$

$$RpetitC\_\_{}_{}=CR1\times SC{1}_{}+CR2\times CS{2}_{}+CR3\times SC{3}_{}\text{\hspace{1em}( 16 )}$$

$$Rgros{\_}_{}=RA\_\times SA{\_}_{}+RB\times S{B}_{}+RC\times SC{\_}_{}$$

Parmi eux, RA1 est le coût d'inventaire d'une seule pièce du gros composant A, et SA1 _d est la quantité restante du gros composant A le jour j. Les autres symboles sont identiques. RsmallA _d , RsmallB _d et RsmallC _d sont les coûts d'inventaire des petits composants A, B et C le jour j, Rsmall les coûts d'inventaire du gros composant le jour j et R _d est le coût total d'inventaire du jour j.
La somme est le coût des stocks au jour j :

$$R_{}=RpetiteA\_\_{}_{}+RpetitB\_\_{}_{}+RpetitC\_\_{}_{}+Rgros{\_}_{}+RW\times SW{\_}_{}\text{\hspace{1em}( 17 )}$$

5.1.9 Coûts de préparation de la production

Lorsqu'une usine fabrique un produit composant, elle doit payer un coût fixe indépendant de la quantité de production, appelé coût de préparation de la production.Afin de faciliter le calcul du coût fixe, une variable 0-1 est introduite ici. Prenons l'exemple de la variable 0-1 XW _d d'un robot de production . Si un robot est produit le jour j, alors XW _d vaut 1 ; si aucun robot n'est produit le jour j, alors XW _d vaut 0. Comme suit

$$X{L}_{}=\{\begin{array}{ll}1& M{F}_{}>0\\ & M{F}_{}=\end{array}\text{\hspace{1em}( 18 )}$$

Les variables 0-1 des autres composantes peuvent être obtenues de la même manière.

Par conséquent, selon les variables 0-1 de tous les composants, le coût de préparation de la production des petits composants, des grands composants et des robots peut être exprimé.

$$FpetitA\_\_{}_{}=XA{1}_{}\times FA1\_+XA{2}_{}\times FA2\_+XA{3}_{}\times FA3\_$$

$$FpetitB\_\_{}_{}=XB{1}_{}\times FB1+XB{2}_{}\times FB2$$

$$FpetitC\_\_{}_{}=XC{1}_{}\times FC1+XC{2}_{}\times CF2+XC{3}_{}\times FC3\text{\hspace{1em}( 19 )}$$

$$Fgros{\_}_{}=FA\_\times X{A}_{}+Facebook\times X{B}_{}+CF\times X{C}_{}$$

Parmi eux, XA1 _d est la variable 0-1 indiquant s'il faut produire de l'Al le jour j, et FA1 est le coût de préparation de la production d'Al.
Les autres symboles sont identiques. FsmallA _d , FsmallB _d et FsmallC _d sont les coûts de préparation de production des petits composants A, B et C le jour j, et le coût d'inventaire des Fbig gros composants le jour j. F _d est le coût de préparation de la production le jour j.

La somme est le coût de préparation de la production au jour j :
$$F_{}=FpetitA\_\_{}_{}+FpetitB\_\_{}_{}+FpetitC\_\_{}_{}+Fgros{\_}_{}+X{L}_{}\times FW\text{\hspace{1em}( 20 )}$$

5.1.10 Fonction objectif

Le coût total doit être le plus petit, c'est-à-dire que la somme du coût d'inventaire et du coût de préparation de la production est la plus petite, et la fonction objectif peut être obtenue :

$$minC=\sum _{ré=1}{R}_{}+\sum _{ré=1}{F}_{}\text{\hspace{1em}( 21 )}$$

5.2 Résolution de problèmes du modèle

L'algorithme de recuit simulé est combiné avec l'algorithme d'essaim de particules, et le code est écrit dans MATLAB pour obtenir le résultat du problème un, comme indiqué ci-dessous.

Le résultat ici est un peu problématique, il devrait être 7000+.

function [X,F]=chushihua1(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C)
%初始化变量、计算目标函数值
flag1=0;
while flag1==0
X=[];
flag1=1;
KC_WPCR=zeros(1,length(WPCR));%记录每天WPCR库存
KC=zeros(3,length(WPCR));%记录每天ABC库存
SY_WPCR=zeros(1,length(WPCR));%记录每天交付WPCR情况
SY=zeros(3,length(WPCR));%记录每天使用ABC情况
SC_WPCR=zeros(1,length(WPCR));%记录每天组装WPCR情况
SC=zeros(3,length(WPCR));%记录每天生产ABC情况
for i=1:length(WPCR)%循环遍历每个WPCR
    if i==1%第一天0库存
        sub=[A_x,B_x,C_x].*WPCR(i);%求出每天的最小ABC需求量
        up=[];
        up(1)=fix((T(i)-sub([2,3])*[TB;TC])/TA);%BC最低供应时，A最大供应量
        up(2)=fix((T(i)-sub([1,3])*[TA;TC])/TB);%AC最低供应时，B最大供应量
        up(3)=fix((T(i)-sub([1,2])*[TA;TB])/TC);%AC最低供应时，B最大供应量
        up=min(up,fix(T(i)./([A_x,B_x,C_x]*[TA;TB;TC])).*[A_x,B_x,C_x]);
    else
        sub=max([A_x,B_x,C_x].*WPCR(i)-KC(:,i-1)',0);%除了第一天，每天减去前一天的库存则为当天至少增加的需求量
        up=[];
        up(1)=fix((T(i)-sub([2,3])*[TB;TC])/TA);%BC最低供应时，A最大供应量
        up(2)=fix((T(i)-sub([1,3])*[TA;TC])/TB);%AC最低供应时，B最大供应量
        up(3)=fix((T(i)-sub([1,2])*[TA;TB])/TC);%AC最低供应时，B最大供应量
        up=min(up,fix(T(i)./([A_x,B_x,C_x]*[TA;TB;TC])).*[A_x,B_x,C_x]);
    end
    %前面的变量会影响后面的变量范围，可能会出现上up小于sub的情况，毕竟有最大工时限制
    if length(find((up-sub)<0))>0%如果出现则重新生成
        flag1=0;
        continue
    end
    flag2=0;
    while flag2==0
        x=[randi([sub(1),up(1)]),randi([sub(2),up(2)]),randi([sub(3),up(3)])];%在区间内随机生成整数
        if x*[TA;TB;TC]<=T(i)%需求量必须满足在工时限制内
            flag2=1;
        end
    end
    %每天组装的WPCR
    if i==1
        s=WPCR(i);%可组装最小数量
        u=min(fix(x./[A_x,B_x,C_x]));%可组装最大数量
    else
        s=WPCR(i)-KC_WPCR(i-1);
        u=min(fix([x+KC(:,i-1)']./[A_x,B_x,C_x]));
    end
    %更新SC、KC、SY矩阵
    %生产
    SC_WPCR(i)=randi([s,u]);
    SC(:,i)=SC(:,i)+x';
    %放库存
    if i==1
        KC_WPCR(i)=KC_WPCR(i)+SC_WPCR(i);
        KC(:,i)=KC(:,i)+SC(:,i);
    else
        KC_WPCR(i)=KC_WPCR(i-1)+SC_WPCR(i);
        KC(:,i)=KC(:,i-1)+SC(:,i);
    end
    %使用
    SY_WPCR(i)=WPCR(i);
    SY(:,i)=[A_x;B_x;C_x].*SC_WPCR(i);
    %更新库存
    KC_WPCR(i)=KC_WPCR(i)-WPCR(i);
    KC(:,i)=KC(:,i)-SY(:,i);
end
X=[SC_WPCR;SC];
X=reshape(X',1,28);
end
X1=[SC_WPCR;SC];%生产
X2=[KC_WPCR;KC];%库存
X1(find(X1>0))=1;
%最优情况，小件无库存但是有生产准备费用
f1=sum(X1.*[W(1);sum(W(2:5));sum(W(6:8));sum(W(9:12))],2);
f2=sum(X2.*C([1,2,6,9])',2);
F=sum(f1)+sum(f2);"

function J=jianyan1(X,WPCR,A_x,B_x,C_x)
%检验变量参与运算后是否出现小于0的值，是则不满足条件
X=X';
KC_WPCR=zeros(1,length(WPCR));%记录每天WPCR库存
KC=zeros(3,length(WPCR));%记录每天ABC库存
SY_WPCR=zeros(1,length(WPCR));%记录每天交付WPCR情况
SY=zeros(3,length(WPCR));%记录每天使用ABC情况
SC_WPCR=zeros(1,length(WPCR));%记录每天组装WPCR情况
SC=zeros(3,length(WPCR));%记录每天生产ABC情况
for i=1:length(WPCR)%循环遍历每个WPCR
    x=X(i,2:4);
    %更新SC、KC、SY矩阵
    %生产
    SC_WPCR(i)=X(i,1);
    SC(:,i)=SC(:,i)+x';
    %放库存
    if i==1
        KC_WPCR(i)=KC_WPCR(i)+SC_WPCR(i);
        KC(:,i)=KC(:,i)+SC(:,i);
    else
        KC_WPCR(i)=KC_WPCR(i-1)+SC_WPCR(i);
        KC(:,i)=KC(:,i-1)+SC(:,i);
    end
    %使用
    SY_WPCR(i)=WPCR(i);
    SY(:,i)=[A_x;B_x;C_x].*SC_WPCR(i);
    %更新库存
    KC_WPCR(i)=KC_WPCR(i)-WPCR(i);
    KC(:,i)=KC(:,i)-SY(:,i);
end
if length(find(KC_WPCR<0))>0 | length(find(KC<0))>0
    J=1;
else
    J=0;
end 

function [F,f1,f2]=fun1(X,WPCR,A_x,B_x,C_x,W,C)
%带入变量计算目标函数值
X=reshape(X',7,4);
KC_WPCR=zeros(1,length(WPCR));%记录每天WPCR库存
KC=zeros(3,length(WPCR));%记录每天ABC库存
SY_WPCR=zeros(1,length(WPCR));%记录每天交付WPCR情况
SY=zeros(3,length(WPCR));%记录每天使用ABC情况
SC_WPCR=zeros(1,length(WPCR));%记录每天组装WPCR情况
SC=zeros(3,length(WPCR));%记录每天生产ABC情况
for i=1:length(WPCR)%循环遍历每个WPCR
    x=X(i,2:4);
    %更新SC、KC、SY矩阵
    %生产
    SC_WPCR(i)=X(i,1);
    SC(:,i)=SC(:,i)+x';
    %放库存
    if i==1
        KC_WPCR(i)=KC_WPCR(i)+SC_WPCR(i);
        KC(:,i)=KC(:,i)+SC(:,i);
    else
        KC_WPCR(i)=KC_WPCR(i-1)+SC_WPCR(i);
        KC(:,i)=KC(:,i-1)+SC(:,i);
    end
    %使用
    SY_WPCR(i)=WPCR(i);
    SY(:,i)=[A_x;B_x;C_x].*SC_WPCR(i);
    %更新库存
    KC_WPCR(i)=KC_WPCR(i)-WPCR(i);
    KC(:,i)=KC(:,i)-SY(:,i);
end
X1=[SC_WPCR;SC];%生产
X2=[KC_WPCR;KC];%库存
X1(find(X1>0))=1;
%最优情况，小件无库存但是有生产准备费用
f1=sum(X1.*[W(1);sum(W(2:5));sum(W(6:8));sum(W(9:12))],1)';
f2=sum(X2.*C([1,2,6,9])',1)';
F=sum(f1)+sum(f2);

clear all
clc
%每天WPCR需求量
WPCR=[39 36 38 40 37 33 40];
%一个WPCR队ABC需求比例
A_x=3;
B_x=4;
C_x=5;
%每天总工时
T=[4500 2500 2750 2100 2500 2750 1500];
%ABC单位工时消耗
TA=3;
TB=5;
TC=5;
%生产准备费用：A A1 A2 A3 B B1 B2 C C1 C2 C3
W=[240 120 40 60 50 160 80 100 180 60 40 70];
%单件库存费用：A A1 A2 A3 B B1 B2 C C1 C2 C3
C=[5 2 5 3 6 1.5 4 5 1.7 3 2 3];

%模拟退火-粒子群算法
T0=100; %初始化温度值
T_min=1; %设置温度下界
alpha=0.95; %温度的下降率
c1=0.4;c2=0.6; %学习因子
wmax=0.6;wmin=0.4; %惯性权重
num=1000; %颗粒总数，效果不好可以增加
X=[];
F=[];
for i=1:num
    [X(i,:),F(i,1)]=chushihua1(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C);
end
%以最小化为例
[bestf,a]=min(F);
bestx=X(a,:);
trace(1)=bestf;
while(T0>T_min)
    XX=[];
    FF=[];
 for i=1:num
        [XX(i,:),FF(i,1)]=chushihua1(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C);
        delta=FF(i,1)-F(i,1);
        if delta<0
            F(i,1)=FF(i,1);
            X(i,:)=XX(i,:);
        else
            P=exp(-delta/T0);
            if P>rand
                F(i,1)=FF(i,1);
                X(i,:)=XX(i,:);
            end
        end  
    end
    fave=mean(F);
    fmin=min(F);
    for i=1:num
        %权重更新
        if F(i)<=fave
            w=wmin+(F(i)-fmin)*(wmax-wmin)/(fave-fmin);
        else
            w=wmax;
        end
        [~,b]=min(F);
        best=X(b,:);%当前最优解
        v=w.*randn(1,28)+c1*rand*(best-X(i,:))+c2*rand*(bestx-X(i,:));%速度
        XX(i,:)=round(X(i,:)+v);%更新位置
        XX(i,:)=max(XX(i,:),0);%不能小于0
        %检验，不满足条件则返回之前的变量
        x=reshape(XX(i,:)',7,4)';%重新排列矩阵维度
        J=jianyan1(X,WPCR,A_x,B_x,C_x);
        if length(find((sum(x(2:4,:).*[TA;TB;TC],1)-T)>0))>0 | sum(x(1,:))<sum(WPCR) | J==1
            XX(i,:)=X(i,:);
        end
        %计算目标函数
        FF(i,1)=fun1(X(i,:),WPCR,A_x,B_x,C_x,W,C);
        %更新最优
        if FF(i,1)<F(i,1)
            F(i,1)=FF(i,1);
            X(i,:)=XX(i,:);
        end 
    end
    if min(F)<bestf
        [bestf,a]=min(F);
        bestx=X(a,:);
    end
    trace=[trace;bestf];
    T0=T0*alpha;
end
disp('最优解为：')
disp('WPCR组装数量、A组装数量、B组装数量、C组装数量')
disp(reshape(bestx',7,4))
disp('生产准备费用、库存费用')
[~,f1,f2]=fun1(bestx,WPCR,A_x,B_x,C_x,W,C)
disp('总费用')
disp(bestf)
figure
plot(trace)
xlabel('迭代次数')
ylabel('函数值')
title('模拟退火算法')
legend('最优值')

6. Résumé et solution du modèle du problème 2

6.1 Établissement du deuxième modèle de problème

6.1.1 Les petits composants assemblent les grands composants

Les composants A, B et C doivent être produits et stockés un jour à l'avance pour assembler le WPCR, et les composants A1, A2, A3, B1, B2, C1, C2 et C3 doivent également être produits et stockés. un jour à l'avance pour assembler A, B et C. Par conséquent, si vous souhaitez terminer la demande de commande de composants le lundi, vous devez assembler les grands composants A, B et C requis le lundi de la semaine dernière le dimanche. Et dimanche dernier, les petits composants utilisés pour assembler les gros composants devraient être assemblés le dernier samedi.
Ainsi, le nombre de petits composants utilisés pour assembler les gros composants au jour j doit être la somme du nombre de petits composants assemblés au jour j-1 et du nombre de petits composants restant au jour j-1. Par conséquent, les formules (5) et (6) sont modifiées pour obtenir les contraintes des grandes composantes, comme suit :
$$MA{\_}_{}⩽min\left[\left(\begin{array}{c}\frac{MA{1}_{ré-}+SA{1}_{ré-}}{6},\frac{MA{2}_{ré-}+SA{2}_{ré-}}{8},\frac{MA{3}_{ré-}+SA{3}_{ré-}}{2}\end{array}\right)\right]$$

$$M{B}_{}⩽min\left[\left(\begin{array}{c}\frac{Mo{1}_{ré-}+SB{1}_{ré-}}{2},\frac{Mo{2}_{ré-}+SB{2}_{ré-}}{4}\end{array}\right)\right]\text{\hspace{1em}( 22 )}$$

$$M{C}_{}⩽min\left[\left(\begin{array}{c}\frac{CM{1}_{ré-}+SC{1}_{ré-}}{8},\frac{MC{2}_{ré-}+CS{2}_{ré-}}{2},\frac{MC{3}_{ré-}+SC{3}_{ré-}}{12}\end{array}\right)\right]$$

6.1.2 Widgets restants

Le nombre de widgets restants le jour j, c'est-à-dire le nombre de widgets qui doivent être stockés, peut être vu en deux parties. Une partie est le nombre de petits composants assemblés au jour j, et l'autre partie est la part restante des gros composants assemblés au jour j, et le reste doit être le nombre de petits composants assemblés au jour j-1 et le nombre de petits composants restants au jour j-1 et, diminuée de la quantité consommée au jour j,

Jour j restant { quantité assemblée le jour j + (quantité assemblée le jour j − 1 + quantité restante le jour j − 1) − quantité consommée le jour j restante le jour d\begin{cases} jour j Quantité assemblée\\ +\ \ (Quantité Assemblée au Jour j-1 + Quantité Restante au Jour j-1) - Quantité Consommée au Jour j\end{cases}Jour j restant⎩ ⎨ ⎧Quantité assemblée le jour j+(e d−Quantité assemblée en 1 jour+ré _−1 jour de quantité restante)−Quantité consommée le jour j

Ainsi, le reste du widget ressemble à ceci :

$$SA1\_{}_{}=MA{1}_{}+MA{1}_{ré-}+SA1\_{}_{ré-}-6\times MA{\_}_{}$$
$$SA2\_{}_{}=MA{2}_{}+MA{2}_{ré-}+SA2\_{}_{ré-}-8\times MA{\_}_{}$$
$$SA3\_{}_{}=MA{3}_{}+MA{3}_{ré-}+SA3\_{}_{ré-}-2\times MA{\_}_{}$$
$$SB{1}_{}=Mo{1}_{}+Mo{1}_{ré-}+SB{1}_{ré-}-2\times M{B}_{}$$

$$SB{2}_{}=Mo{2}_{}+Mo{2}_{ré-}+SB{2}_{ré-}-4\times M{B}_{}\text{\hspace{1em}( 23 )}$$
$$SC{1}_{}=CM{1}_{}+CM{1}_{ré-}+SC{1}_{ré-}-8\times M{C}_{}$$
$$CS{2}_{}=MC{2}_{}+MC{2}_{ré-}+CS{2}_{ré-}-2\times M{C}_{}$$
$$SC{3}_{}=MC{3}_{}+MC{3}_{ré-}+SC{3}_{ré-}-12\times M{C}_{}$$

6.1.3 La quantité d'assemblage du robot calcule les gros composants restants

L'assemblage du robot est le même que l'assemblage des petits composants aux gros composants. Au jour j, le robot est assemblé à partir de l'assemblage du jour j-1 ou des gros composants restants. Les contraintes sont les suivantes :

$$M{F}_{}⩽min\left[\left(\begin{array}{c}\frac{MA{1}_{ré-}+SA{1}_{ré-}}{3},\frac{Mo{2}_{ré-}+SB{2}_{ré-}}{4},\frac{MC{3}_{ré-}+SC{3}_{ré-}}{5}\end{array}\right)\right]\text{\hspace{1em}( 24 )}$$

Le reste du grand composant est le même que le reste du petit composant, comme suit :

$$SA{\_}_{}=MA{\_}_{}+MA{\_}_{ré-}+SA{\_}_{ré-}-3\times M{F}_{}$$
$$S{B}_{}=M{B}_{}+M{B}_{ré-}+S{B}_{ré-}-4\times M{F}_{}\text{\hspace{1em}( 25 )}$$
$$SC{\_}_{}=M{C}_{}+M{C}_{ré-}+SC{\_}_{ré-}-5\times M{F}_{}$$

6.1.4 Contraintes de quantité d'assemblage de robot et calcul résiduel

La quantité d'assemblage et le reste du robot ne sont pas modifiés comme suit :

$$M{F}_{}+SW{\_}_{ré-}⩾DW{\_}_{}\text{\hspace{1em}( 26 )}$$
$$SW{\_}_{}=M{C}_{}+M{F}_{ré-}+SW{\_}_{ré-}-DW{\_}_{}\text{\hspace{1em}( 26 )}$$

6.1.5 Garantir la production du lendemain

Afin d'assurer la production le lundi de la semaine prochaine, les composants doivent être laissés à la fin de cette semaine le dimanche, donc les équations (13) et (14) de la question 1 ne doivent pas être prises en compte. Considérez le lundi suivant comme le 8e jour, donc la somme du nombre de robots assemblés le 8e jour et du nombre de robots restants le 7e jour ne doit pas être inférieure à la quantité commandée 39 le lundi suivant, comme suit :

$$M{F}_{}+SW{\_}_{8-}⩾39\text{\hspace{1em}( 26 )}$$

Il est à noter qu'en cette semaine, afin d'assurer la production des robots le jour j, les contraintes sur la quantité d'assemblage des gros composants le jour j et la quantité d'assemblage des petits composants le jour j-1 ne sont pas clairement données. Or, dans l'équation (26), il existe une contrainte sur la quantité commandée DW _d de robots le jour j et la quantité MW _{d fabriquée le jour j} . Il existe une contrainte sur la quantité d'assemblage de gros composants le jour j, dans l'équation (22), il y a une contrainte sur la quantité d'assemblage de petits composants au jour j-1 sur le nombre de gros composants assemblés au jour j.

Par conséquent, les contraintes pour garantir le nombre de robots produits le deuxième jour ne sont pas explicitement données, mais elles sont implicites.

6.1.6 Restrictions sur les heures de travail

La limite d'heures de travail n'est pas modifiée comme suit :
$$3\times MA{\_}_{}+5\times M{B}_{}+5\times M{C}_{}⩽J_{}\text{\hspace{1em}( 27 )}$$

6.1.7 Fonction objectif

La fonction objectif n'est pas modifiée et est identique au problème 1 comme suit :
$$minC=\sum _{ré=1}{R}_{}+\sum _{ré=1}{F}_{}\text{\hspace{1em}( 28 )}$$

6.2 La solution du deuxième modèle de problème

Utilisez MATLAB pour écrire le code pour obtenir le résultat de la deuxième question.

clear
clc
%每天WPCR需求量
WPCR=[39 36 38 40 37 33 40];
%一个WPCR队ABC需求比例
A_x=3;
B_x=4;
C_x=5;
D_x=[6;8;2;2;4;8;2;12];
%每天总工时
T=[4500 2500 2750 2100 2500 2750 1500];
%ABC单位工时消耗
TA=3;
TB=5;
TC=5;
%生产准备费用：A A1 A2 A3 B B1 B2 C C1 C2 C3
W=[240 120 40 60 50 160 80 100 180 60 40 70];
%单件库存费用：A A1 A2 A3 B B1 B2 C C1 C2 C3
C=[5 2 5 3 6 1.5 4 5 1.7 3 2 3];

%模拟退火-粒子群算法
T0=100; %初始化温度值
T_min=1; %设置温度下界
alpha=0.95; %温度的下降率
c1=0.4;c2=0.6; %学习因子
wmax=0.6;wmin=0.4; %惯性权重
num=1000; %颗粒总数
X=[];
F=[];
for i=1:num
    [X(i,:),F(i,1)]=chushihua2(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C,D_x);
end
%以最小化为例
[bestf,a]=min(F);
bestx=X(a,:);
trace(1)=bestf;
while(T0>T_min)
    XX=[];
    FF=[];
 for i=1:num
        [XX(i,:),FF(i,1)]=chushihua2(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C,D_x);
        delta=FF(i,1)-F(i,1);
        if delta<0
            F(i,1)=FF(i,1);
            X(i,:)=XX(i,:);
        else
            P=exp(-delta/T0);
            if P>rand
                F(i,1)=FF(i,1);
                X(i,:)=XX(i,:);
            end
        end  
    end
    fave=mean(F);
    fmin=min(F);
    for i=1:num
        %权重更新
        if F(i)<=fave
            w=wmin+(F(i)-fmin)*(wmax-wmin)/(fave-fmin);
        else
            w=wmax;
        end
        [~,b]=min(F);
        best=X(b,:);%当前最优解
        v=w.*randn(1,28)+c1*rand*(best-X(i,:))+c2*rand*(bestx-X(i,:));%速度
        XX(i,:)=round(X(i,:)+v);%更新位置
        XX(i,:)=max(XX(i,:),0);%不能小于0
        %检验，不满足条件则返回之前的变量
        x=reshape(XX(i,:)',7,4)';%重新排列矩阵维度
        J=jianyan2(X,WPCR,A_x,B_x,C_x,D_x);
        if length(find((sum(x(2:4,:).*[TA;TB;TC],1)-T)>0))>0 | sum(x(1,:))<sum(WPCR) | J==1
            XX(i,:)=X(i,:);
        end
        %计算目标函数
        FF(i,1)=fun2(X(i,:),WPCR,A_x,B_x,C_x,W,C,D_x);
        %更新最优
        if FF(i,1)<F(i,1)
            F(i,1)=FF(i,1);
            X(i,:)=XX(i,:);
        end 
    end
    if min(F)<bestf
        [bestf,a]=min(F);
        bestx=X(a,:);
    end
    trace=[trace;bestf];
    T0=T0*alpha;
end
disp('最优解为：')
disp('WPCR组装数量、A组装数量、B组装数量、C组装数量')
disp(reshape(bestx',7,4))
disp('生产准备费用、库存费用')
[~,f1,f2]=fun2(bestx,WPCR,A_x,B_x,C_x,W,C,D_x)
disp('总费用')
disp(bestf)
figure
plot(trace)
xlabel('迭代次数')
ylabel('函数值')
title('模拟退火算法')
legend('最优值')

function [X,F]=chushihua2(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C,D_x)
%初始化变量、计算目标函数值，小件提前两天，大件提前1天
flag1=0;
while flag1==0
X=[];
nn=2;%延迟天数
flag1=1;
KC_WPCR=zeros(1,length(WPCR)+nn);%记录每天WPCR库存
KC=zeros(3,length(WPCR)+nn);%记录每天ABC库存
KC_x=zeros(8,length(WPCR)+nn);%记录每天ABC小件库存
SY_WPCR=zeros(1,length(WPCR)+nn);%记录每天交付WPCR情况
SY=zeros(3,length(WPCR)+nn);%记录每天使用ABC情况
SY_x=zeros(8,length(WPCR)+nn);%记录每天使用ABC小件情况
SC_WPCR=zeros(1,length(WPCR)+nn);%记录每天组装WPCR情况
SC=zeros(3,length(WPCR)+nn);%记录每天生产ABC情况
SC_x=zeros(8,length(WPCR)+nn);%记录每天生产ABC小件情况
for i=1:length(WPCR)%循环遍历每个WPCR
    if i==1%假设第一天刚好满足WPCR
        sub=[A_x,B_x,C_x].*WPCR(i);%求出每天的WPCR最小ABC需求量
        up=sub;
    else
        sub=max([A_x,B_x,C_x].*WPCR(i)-KC(:,i+nn-1)',0);%除了第一天，每天减去前一天的库存则为当天至少增加的需求量
        up=[];
        up(1)=fix((T(i)-sub([2,3])*[TB;TC])/TA);%BC最低供应时，A最大供应量
        up(2)=fix((T(i)-sub([1,3])*[TA;TC])/TB);%AC最低供应时，B最大供应量
        up(3)=fix((T(i)-sub([1,2])*[TA;TB])/TC);%AC最低供应时，B最大供应量
        up=min(up,fix(T(i)./([A_x,B_x,C_x]*[TA;TB;TC])).*[A_x,B_x,C_x]);
    end
    %前面的变量会影响后面的变量范围，可能会出现上up小于sub的情况，毕竟有最大工时限制
    if length(find((up-sub)<0))>0%如果出现则重新生成
        flag1=0;
        continue
    end
    flag2=0;
    while flag2==0
        x=[randi([sub(1),up(1)]),randi([sub(2),up(2)]),randi([sub(3),up(3)])];%在区间内随机生成整数
        if x*[TA;TB;TC]<=T(i)%需求量必须满足在工时限制内
            flag2=1;
        end
    end
    %每天组装的WPCR
    if i==1
        s=WPCR(i);%可组装最小数量
        u=min(fix(x./[A_x,B_x,C_x]));%可组装最大数量
    else
        s=WPCR(i)-KC_WPCR(i+nn-1);
        u=min(fix([x+KC(:,i+nn-1)']./[A_x,B_x,C_x]));
    end
    %更新SC、KC、SY矩阵
    %生产
    SC_WPCR(i+nn)=randi([s,u]);
    SC(:,i+nn-1)=SC(:,i+nn-1)+x';
    SC_x(1:3,i)=D_x(1:3).*SC(1,i+nn-1);
    SC_x(4:5,i)=D_x(4:5).*SC(2,i+nn-1);
    SC_x(6:8,i)=D_x(6:8).*SC(3,i+nn-1);
    %放库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn-1)+SC_WPCR(i+nn);
    KC(:,i+nn-1)=KC(:,i+nn-2)+SC(:,i+nn-1);
    if i==1
       KC_x(:,i+nn-2)=SC_x(:,i+nn-2);
    else
       KC_x(:,i+nn-2)=KC_x(:,i+nn-3)+SC_x(:,i+nn-2);
    end
    %使用
    SY_WPCR(i+nn)=WPCR(i);
    SY(:,i+nn)=[A_x;B_x;C_x].*SY_WPCR(i+nn);
    SY_x(1:3,i+nn-1)=D_x(1:3).*SY(1,i+nn);
    SY_x(4:5,i+nn-1)=D_x(4:5).*SY(2,i+nn);
    SY_x(6:8,i+nn-1)=D_x(6:8).*SY(3,i+nn);
    %更新库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn)-WPCR(i);
    KC(:,i+nn)=KC(:,i+nn-1)-SY(:,i+nn);
    KC_x(:,i+nn-1)=KC_x(:,i+nn-2)-SY_x(:,i+nn-1);
end
X=[SC_WPCR(:,nn+1:end);SC(:,nn:end-1)];
X=reshape(X',1,28);
end
X1=[SC_WPCR(:,nn+1:end);SC(:,nn+1:end)];%生产
X2=[SC_x(:,nn+1:end)];%生产ABC小件
X3=[KC_WPCR(:,nn+1:end);KC(:,nn+1:end)];%库存ABC
X4=[KC_x(:,nn+1:end)];%库存ABC小件
X1(find(X1>0))=1;
X2(find(X2>0))=1;
%最优情况，小件无库存但是有生产准备费用
f1=(sum(X1.*[W(1);W(2);W(6);W(9)],1)+sum(X2.*[W(3:5)';W(7:8)';W(10:12)'],1))';
f2=(sum(X3.*C([1,2,6,9])',1)+sum(X4.*C([3,4,5,7,8,10,11,12])',1))';
F=sum(f1)+sum(f2);

function [F,f1,f2]=fun2(X,WPCR,A_x,B_x,C_x,W,C,D_x)
%初始化变量、计算目标函数值
X=reshape(X',7,4);
nn=2;
KC_WPCR=zeros(1,length(WPCR)+nn);%记录每天WPCR库存
KC=zeros(3,length(WPCR)+nn);%记录每天ABC库存
KC_x=zeros(8,length(WPCR)+nn);%记录每天ABC小件库存
SY_WPCR=zeros(1,length(WPCR)+nn);%记录每天交付WPCR情况
SY=zeros(3,length(WPCR)+nn);%记录每天使用ABC情况
SY_x=zeros(8,length(WPCR)+nn);%记录每天使用ABC小件情况
SC_WPCR=zeros(1,length(WPCR)+nn);%记录每天组装WPCR情况
SC=zeros(3,length(WPCR)+nn);%记录每天生产ABC情况
SC_x=zeros(8,length(WPCR)+nn);%记录每天生产ABC小件情况
for i=1:length(WPCR)%循环遍历每个WPCR
    x=X(i,2:4);
    %更新SC、KC、SY矩阵
    %生产
    SC_WPCR(i+nn)=X(i,1);
    SC(:,i+nn-1)=SC(:,i+nn-1)+x';
    SC_x(1:3,i)=D_x(1:3).*SC(1,i+nn-1);
    SC_x(4:5,i)=D_x(4:5).*SC(2,i+nn-1);
    SC_x(6:8,i)=D_x(6:8).*SC(3,i+nn-1);
    %放库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn-1)+SC_WPCR(i+nn);
    KC(:,i+nn-1)=KC(:,i+nn-2)+SC(:,i+nn-1);
    if i==1
       KC_x(:,i+nn-2)=SC_x(:,i+nn-2);
    else
       KC_x(:,i+nn-2)=KC_x(:,i+nn-3)+SC_x(:,i+nn-2);
    end
    %使用
    SY_WPCR(i+nn)=WPCR(i);
    SY(:,i+nn)=[A_x;B_x;C_x].*SY_WPCR(i+nn);
    SY_x(1:3,i+nn-1)=D_x(1:3).*SY(1,i+nn);
    SY_x(4:5,i+nn-1)=D_x(4:5).*SY(2,i+nn);
    SY_x(6:8,i+nn-1)=D_x(6:8).*SY(3,i+nn);
    %更新库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn)-WPCR(i);
    KC(:,i+nn)=KC(:,i+nn-1)-SY(:,i+nn);
    KC_x(:,i+nn-1)=KC_x(:,i+nn-2)-SY_x(:,i+nn-1);
end
X1=[SC_WPCR(:,nn+1:end);SC(:,nn+1:end)];%生产
X2=[SC_x(:,nn+1:end)];%生产ABC小件
X3=[KC_WPCR(:,nn+1:end);KC(:,nn+1:end)];%库存ABC
X4=[KC_x(:,nn+1:end)];%库存ABC小件
X1(find(X1>0))=1;
X2(find(X2>0))=1;
%最优情况，小件无库存但是有生产准备费用
f1=(sum(X1.*[W(1);W(2);W(6);W(9)],1)+sum(X2.*[W(3:5)';W(7:8)';W(10:12)'],1))';
f2=(sum(X3.*C([1,2,6,9])',1)+sum(X4.*C([3,4,5,7,8,10,11,12])',1))';
F=sum(f1)+sum(f2);

function J=jianyan2(X,WPCR,A_x,B_x,C_x,D_x)
%检验变量参与运算后是否出现小于0的值，是则不满足条件
X=X';
nn=2;
KC_WPCR=zeros(1,length(WPCR)+nn);%记录每天WPCR库存
KC=zeros(3,length(WPCR)+nn);%记录每天ABC库存
KC_x=zeros(8,length(WPCR)+nn);%记录每天ABC小件库存
SY_WPCR=zeros(1,length(WPCR)+nn);%记录每天交付WPCR情况
SY=zeros(3,length(WPCR)+nn);%记录每天使用ABC情况
SY_x=zeros(8,length(WPCR)+nn);%记录每天使用ABC小件情况
SC_WPCR=zeros(1,length(WPCR)+nn);%记录每天组装WPCR情况
SC=zeros(3,length(WPCR)+nn);%记录每天生产ABC情况
SC_x=zeros(8,length(WPCR)+nn);%记录每天生产ABC小件情况
for i=1:length(WPCR)%循环遍历每个WPCR
    x=X(i,2:4);
    %更新SC、KC、SY矩阵
    %生产
    SC_WPCR(i+nn)=X(i,1);
    SC(:,i+nn-1)=SC(:,i+nn-1)+x';
    SC_x(1:3,i)=D_x(1:3).*SC(1,i+nn-1);
    SC_x(4:5,i)=D_x(4:5).*SC(2,i+nn-1);
    SC_x(6:8,i)=D_x(6:8).*SC(3,i+nn-1);
    %放库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn-1)+SC_WPCR(i+nn);
    KC(:,i+nn-1)=KC(:,i+nn-2)+SC(:,i+nn-1);
    if i==1
       KC_x(:,i+nn-2)=SC_x(:,i+nn-2);
    else
       KC_x(:,i+nn-2)=KC_x(:,i+nn-3)+SC_x(:,i+nn-2);
    end
    %使用
    SY_WPCR(i+nn)=WPCR(i);
    SY(:,i+nn)=[A_x;B_x;C_x].*SY_WPCR(i+nn);
    SY_x(1:3,i+nn-1)=D_x(1:3).*SY(1,i+nn);
    SY_x(4:5,i+nn-1)=D_x(4:5).*SY(2,i+nn);
    SY_x(6:8,i+nn-1)=D_x(6:8).*SY(3,i+nn);
    %更新库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn)-WPCR(i);
    KC(:,i+nn)=KC(:,i+nn-1)-SY(:,i+nn);
    KC_x(:,i+nn-1)=KC_x(:,i+nn-2)-SY_x(:,i+nn-1);
end
if length(find(KC_WPCR<0))>0 | length(find(KC<0))>0 | length(find(KC_x<0))>0
    J=1;
else
    J=0;
end

7. Établissement et solution du modèle du problème trois

7.1 Établissement du troisième modèle de problème

7.1.1 Détermination des variables temporelles

Dans cette question, le temps est passé de 7 jours à 30 semaines et 210 jours, donc la variable de temps est
$$ré\in (-1,0,1,...,208,209,210)\text{\hspace{1em}( 29 )}$$

d=-1 est le samedi de la semaine précédente de la semaine 1 et d=0 est le dimanche de la semaine précédente de la semaine 1. d=1 est le lundi de la 1ère semaine, qui est le premier jour de la 30e semaine ; d=210 est le dimanche de la 30e semaine, qui est le dernier jour de la 30e semaine.

7.1.2 Variables 0-1 pour les temps d'arrêt

En modélisation, lorsque vous rencontrez le problème qu'une variable peut prendre plusieurs valeurs entières, un ensemble de variables 0-1 peut être utilisé pour remplacer la variable en tirant parti de la propriété qu'une variable 0-1 est une variable binaire. Par conséquent, en vertu de cette propriété, un ensemble de variables 0-1 est introduit pour remplacer une variable de temps d'arrêt 0-1.

En prenant comme exemple la première date de maintenance, le modèle du premier jour de maintenance est établi comme suit :

$$vérifier\_\_{\_}_{}=\{\begin{array}{ll}1& Jourià\; réviser\\ & Pas\; d\text{'}\end{array}\text{\hspace{1em}( 29 )}$$

Dans la formule ci-dessus, la première formule est une variable 0-1, ce qui signifie si la première date de maintenance est le dème jour. Étant donné que le premier jour de maintenance ne peut être que sur l'un des 210 jours, c'est-à-dire qu'il ne peut s'agir que d'un jour, la deuxième formule ci-dessus est introduite pour les contraintes.

Afin d'obtenir facilement la valeur spécifique de la date du premier entretien, la troisième formule dans la formule ci-dessus est introduite en vertu de la propriété que la variable 0-1 est une variable binaire. Par exemple, la date de la 1ère révision est le 3ème jour, alors

$${je}_{}=1\text{\hspace{1em}( 31 )}$$
$${je}_{}={je}_{}={je}_{}=...={je}_{}={je}_{1(210}=0\text{\hspace{1em}( 31 )}$$

A ce moment, la deuxième formule de la formule (30) a été satisfaite.
Alors la troisième formule de (30) peut être transformée en :
$$vérifier\_\_{\_}_{}=2^1{je}_{}+2^2{je}_{}+...+2^{210}{je}_{\left(1\right)}=2^1\times 0+2^2\times 0+2^3\times 1+...+2^{210}\times 0=2^3\text{\hspace{1em}( 31 )}$$

Grâce à la quatrième formule de (30), la date de la première inspection peut être directement obtenue, comme suit :
$$vérifierladate\_\_\_\_\_{}_{}=lo{g}_2^{cochez1\_\_}=lo{g}_2^{(2^3}=3\text{\hspace{1em}( 32 )}$$

Par conséquent, les variables 0-1 de 7 inspections sont obtenues comme suit :

où chechDate _t est la date précise de la t-ième inspection.

7.1.3 Intervalle de contrôle

Afin de donner plus commodément l'intervalle de 6 jours entre deux dates de contrôle, l'ordre des 7 contrôles est d'abord limité, c'est-à-dire que le checkDate _t est trié en premier, comme suit :
$$ch\; echDatei<ch\; echDatei+1,je\in (1,2,\mathrm{3...5},6)\text{\hspace{1em}( 34 )}$$

Après tri, une contrainte de 6 jours entre deux dates de contrôle est donnée, comme suit :

$$ch\; echDatei+6<ch\; echDatei+1,je\in (1,2,\mathrm{3...5},6)\text{\hspace{1em}( 35 )}$$

7.1.4 Définition de la matrice de limite de temps de travail total

Le temps de production dans cette question est passé de 7 jours à 210 jours en 30 semaines, redéfinissez donc la matrice de la limite totale des heures de travail :

Parmi eux, T _d est la limite totale d'heures de travail le jour j de la semaine.

Par conséquent, les contraintes qui satisfont la limite totale d'heures de travail sont les suivantes :

$$3\times MAd+5\times Mod+5\times M{C}_{}⩽Têtre{g}_{}\text{\hspace{1em}( 37 )}$$

7.1.5 Les restrictions sur le nombre total d'heures de travail sont assouplies après la maintenance

Après la révision de l'équipement, la capacité de production a été améliorée Après le premier jour après la révision, le délai de production total est assoupli de 10 %, 8 %, ..., 2 % et 0 %. Par conséquent, une fois les dates précises des 7 inspections déterminées, les valeurs de la matrice de limite maximale d'heures-personnes totales peuvent être modifiées pour répondre à l'assouplissement après l'inspection. Modifiez la formule pour qu'elle ressemble à ceci :

$$Têtre{g}_{(chechDate+offset}=Têtre{g}_{(chechDate+offset}\times (1+(\mathrm{0,1}-\mathrm{0,02}\times désactivé\left)\right)\_\_\text{\hspace{1em}( 38 )}$$

$$offsett\_\in (0,1,...4,5)$$

Parmi eux, 1, décalage est le décalage de date, qui est décalé en arrière à partir de la date de chaque maintenance, et l'assouplissement limite est réduit de 2 % pour chaque décalage. Lorsque le décalage atteint 5 fois, la relaxation limite est réduite à 0 % et le décalage est arrêté.

7.1.6 Aucun composant ne peut être produit le jour de l'inspection

Le jour de la maintenance de l'équipement, aucun composant ne peut être produit, c'est-à-dire que la sortie des gros composants, des petits composants et des robots le jour de la maintenance est de 0, les contraintes sont donc les suivantes :

$$MA{1}_{}=MA{2}_{}=MA{3}_{}=Mo{1}_{}=Mo{2}_{}=CM{1}_{}=MC{2}_{}=MC{3}_{}=0$$
$$MA{\_}_{}=M{B}_{}=M{C}_{}=M{F}_{}=0\text{\hspace{1em}( 39 )}$$
$$j\in (vérifierladate\_\_\_\_\_{}_{},t\in (1,2,...6,7))$$

7.1.7 Assurer la poursuite de la production

Afin de s'assurer qu'après la fin des 30 semaines et 210 jours, la demande de commande puisse encore être satisfaite le lundi 31e semaine, c'est-à-dire le 211e jour, de sorte que la quantité de production MW du robot le 211e jour et le reste la quantité SW11- du robot le jour 210 ne doit pas être inférieure au jour 211. DW.1, la quantité demandée du robot céleste, le principe est le même que celui de 6.1.5. Les contraintes sont les suivantes :

$$M{F}_{}+SW{\_}_{211-}⩾DW{\_}_{}\text{\hspace{1em}( 40 )}$$

La question ne donne pas la demande du robot le 211ème jour DW_{211}, ici les données du lundi sur 30 semaines sont moyennées et arrondies pour obtenir DW ₂₁₁ =38.

Les autres contraintes et fonctions objectifs n'ont pas été modifiées dans le modèle du problème 2, elles ne seront donc pas répétées ici.

7.2 La solution du problème des trois modèles

Utilisez MATLAB pour écrire du code afin d'obtenir le résultat de la troisième question.

clear
clc
%每天WPCR需求量
WPCR=[39 36 38 40 37 33 40
39 33 37 43 34 30 39
42 36 35 38 36 35 41
38 36 36 48 34 35 39
38 36 40 40 40 34 39
40 30 36 40 34 36 37
41 36 41 41 38 29 43
33 31 40 42 42 30 40
35 36 38 33 35 37 41
43 35 42 37 36 33 39
38 32 41 36 40 31 34
37 37 41 39 38 35 38
38 38 33 42 42 29 33
39 37 44 38 35 36 38
40 39 38 38 37 34 44
35 36 38 39 39 39 39
43 28 39 41 38 30 38
35 37 40 41 40 35 41
36 35 40 41 37 38 36
37 38 39 41 38 37 44
37 37 37 36 39 33 41
39 37 42 37 36 28 43
40 32 35 45 40 34 43
38 36 37 36 40 28 45
38 40 38 36 35 40 42
31 31 44 36 31 36 40
40 36 34 43 35 32 39
33 33 36 41 34 38 40
35 34 37 37 39 36 40
37 41 39 41 36 32 44];
WPCR=reshape(WPCR',210,1)';
WPCR=[WPCR,WPCR(1:2)];
%一个WPCR队ABC需求比例
A_x=3;
B_x=4;
C_x=5;
D_x=[6;8;2;2;4;8;2;12];
%每天总工时
T=repmat([4500 2500 2750 2100 2500 2750 1500],1,30);
T=[T(end),T,T(1)];
%ABC单位工时消耗
TA=3;
TB=5;
TC=5;
%生产准备费用：A A1 A2 A3 B B1 B2 C C1 C2 C3
W=[240 120 40 60 50 160 80 100 180 60 40 70];
%单件库存费用：A A1 A2 A3 B B1 B2 C C1 C2 C3
C=[5 2 5 3 6 1.5 4 5 1.7 3 2 3];

%模拟退火-粒子群算法
T0=100; %初始化温度值
T_min=1; %设置温度下界
alpha=0.9; %温度的下降率
c1=0.4;c2=0.6; %学习因子
wmax=0.6;wmin=0.4; %惯性权重
num=2; %颗粒总数
X=[];
A=[];
F=[];
for i=1:num
    [X(i,:),A(i,:),F(i,1)]=chushihua3(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C,D_x);
end
%以最小化为例
[bestf,a]=min(F);
bestx=X(a,:);
bestA=A(a,:);
trace(1)=bestf;
while(T0>T_min)
    XX=[];
    FF=[];
    AA=[];
 for i=1:num
        [XX(i,:),AA(i,:),FF(i,1)]=chushihua3(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C,D_x);
        delta=FF(i,1)-F(i,1);
        if delta<0
            F(i,1)=FF(i,1);
            X(i,:)=XX(i,:);
            A(i,:)=AA(i,:);
        else
            P=exp(-delta/T0);
            if P>rand
                F(i,1)=FF(i,1);
                X(i,:)=XX(i,:);
                A(i,:)=AA(i,:);
            end
        end  
    end
    fave=mean(F);
    fmin=min(F);
    for i=1:num
        %权重更新
        if F(i)<=fave
            w=wmin+(F(i)-fmin)*(wmax-wmin)/(fave-fmin);
        else
            w=wmax;
        end
        [~,b]=min(F);
        best=X(b,:);%当前最优解
        %粒子群算法限制最多找10次位置
        m=1;
        flag=0;
        while flag==1
        v=w.*randn(1,28)+c1*rand*(best-X(i,:))+c2*rand*(bestx-X(i,:));%速度
        XX(i,:)=round(X(i,:)+v);%更新位置
        XX(i,:)=max(XX(i,:),0);%不能小于0
        %检验，不满足条件则返回之前的变量
        x=reshape(XX(i,:)',7,4)';%重新排列矩阵维度
        J=jianyan3(x,AA(i,:),WPCR,A_x,B_x,C_x);
        if (length(find((sum(x(2:4,:).*[TA;TB;TC],1)-T)>0))==0 & sum(x(1,:))>=sum(WPCR) & J==0) | m==10
            XX(i,:)=X(i,:);
        else
            m=m+1;
        end
        end
        %计算目标函数
        FF(i,1)=fun3(XX(i,:),AA(i,:),WPCR,A_x,B_x,C_x,W,C,D_x);
        %更新最优
        if FF(i,1)<F(i,1)
            F(i,1)=FF(i,1);
            X(i,:)=XX(i,:);
            A(i,:)=AA(i,:);
        end 
    end
    if min(F)<bestf
        [bestf,a]=min(F);
        bestx=X(a,:);
        bestA=A(a,:);
    end
    trace=[trace;bestf];
    T0=T0*alpha;
end
disp('最优解为：')
disp('停检时间')
disp(bestA)
disp('WPCR组装数量、A组装数量、B组装数量、C组装数量，见工作区矩阵zz')
x=reshape(bestx',212,4);
zz=[x(1:210,1),x(2:211,2:4)];
disp('生产准备费用、库存费用见工作区矩阵f1、f2')
[~,f1,f2]=fun3(bestx,bestA,WPCR,A_x,B_x,C_x,W,C,D_x);
disp('总费用')
disp(bestf)
figure
plot(trace)
xlabel('迭代次数')
ylabel('函数值')
title('模拟退火算法')
legend('最优值')

function [X,b,F]=chushihua3(WPCR,A_x,B_x,C_x,T,TA,TB,TC,W,C,D_x)
%初始化变量、计算目标函数值，小件提前两天，大件提前1天
flag1=0;
while flag1==0
%检修
flag3=0;
while flag3==0
    A=zeros(1,length(WPCR));
    a=10+randperm(length(WPCR)-20);
    aa=a(1:7);
    A(aa)=1;
    b=find(A==1);
    c=b(2:end)-b(1:end-1);
    d=find(c<6);
    if length(d)==0
        flag3=1;
    end
end
%检修后提高效率
AA=[];%对应的时间
for i=1:length(b)
    AA=[AA,b(i)+1:b(i)+5];
end
G=repmat([1.1 1.08 1.06 10.4 1.02],1,length(b));
TT=T;
TT(AA)=TT(AA).*G;
X=[];
nn=2;%延迟天数
flag1=1;
KC_WPCR=zeros(1,length(WPCR)+nn);%记录每天WPCR库存
KC=zeros(3,length(WPCR)+nn);%记录每天ABC库存
KC_x=zeros(8,length(WPCR)+nn);%记录每天ABC小件库存
SY_WPCR=zeros(1,length(WPCR)+nn);%记录每天交付WPCR情况
SY=zeros(3,length(WPCR)+nn);%记录每天使用ABC情况
% SY_x=zeros(8,length(WPCR)+nn);%记录每天使用ABC小件情况
SC_WPCR=zeros(1,length(WPCR)+nn);%记录每天组装WPCR情况
SC=zeros(3,length(WPCR)+nn);%记录每天生产ABC情况
SC_x=zeros(8,length(WPCR)+nn);%记录每天生产ABC小件情况
for i=1:length(WPCR)%循环遍历每个WPCR
    if i==1%假设第一天刚好满足WPCR
        sub=[A_x,B_x,C_x].*WPCR(i);%求出每天的WPCR最小ABC需求量
        up=sub;
    else
        sub=max([A_x,B_x,C_x].*WPCR(i)-KC(:,i+nn-1)',0);%除了第一天，每天减去前一天的库存则为当天至少增加的需求量
        up=[];
        up(1)=fix((T(i)-sub([2,3])*[TB;TC])/TA);%BC最低供应时，A最大供应量
        up(2)=fix((T(i)-sub([1,3])*[TA;TC])/TB);%AC最低供应时，B最大供应量
        up(3)=fix((T(i)-sub([1,2])*[TA;TB])/TC);%AC最低供应时，B最大供应量
        up=min(up,fix(T(i)./([A_x,B_x,C_x]*[TA;TB;TC])*2).*[A_x,B_x,C_x]);
    end
    %前面的变量会影响后面的变量范围，可能会出现上up小于sub的情况，毕竟有最大工时限制
    if length(find((up-sub)<0))>0%如果出现则重新生成
        flag1=0;
        continue
    end
    flag2=0;
    while flag2==0
        x=[randi([sub(1),up(1)]),randi([sub(2),up(2)]),randi([sub(3),up(3)])];%在区间内随机生成整数
        if i==1
            flag2=1;
        elseif i>1
            if x*[TA;TB;TC]<=T(i)%需求量必须满足在工时限制内
                flag2=1;
            end
        end
    end
    %每天组装的WPCR
    if i==1
        s=WPCR(i);%可组装最小数量
        u=min(fix(x./[A_x,B_x,C_x]));%可组装最大数量
    else
        s=max(WPCR(i)-KC_WPCR(i+nn-1),0);
        u=min(fix([x+KC(:,i+nn-1)']./[A_x,B_x,C_x]));
    end
    if u<s
        flag1=0;
        continue
    end
    %更新SC、KC、SY矩阵
    %生产
    if length(find(b==i))==1
        SC_WPCR(i+nn)=0;
    else
        SC_WPCR(i+nn)=randi([s,u]);
    end
    if length(find(b==i-1))==1
        SC(:,i+nn-1)=0;
    else
        SC(:,i+nn-1)=SC(:,i+nn-1)+x';
    end
    %放库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn-1)+SC_WPCR(i+nn);
    if KC_WPCR(i+nn)<0
        KC_WPCR(i+nn)=0;
    end
    if i==1
        KC(:,i+nn-1)=SC(:,i+nn-1);
    else
        KC(:,i+nn-1)=KC(:,i+nn-1)+SC(:,i+nn-1);
    end
    KC_x(1:3,i+nn-2)=D_x(1:3).*SC(1,i+nn-1);
    KC_x(4:5,i+nn-2)=D_x(4:5).*SC(2,i+nn-1);
    KC_x(6:8,i+nn-2)=D_x(6:8).*SC(3,i+nn-1);
    %使用
    SY_WPCR(i+nn)=WPCR(i);
    SY(:,i+nn)=[A_x;B_x;C_x].*SY_WPCR(i+nn);
    %更新库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn)-WPCR(i);
    KC(:,i+nn)=KC(:,i+nn-1)-SY(:,i+nn);
end
X=[SC_WPCR(:,nn+1:end);SC(:,nn:end-1)];
X=reshape(X',1,848);
end
X1=[SC_WPCR(:,nn+1:end-2);SC(:,nn+1:end-2)];%生产
X3=[KC_WPCR(:,nn+1:end-2);KC(:,nn+1:end-2)];%库存ABC
X4=[KC_x(:,nn+1:end-2)];%库存ABC小件
X1(find(X1>0))=1;
X2=[repmat(X1(2,:),3,1);repmat(X1(3,:),2,1);repmat(X1(4,:),3,1)];
X2(:,b)=0;
%最优情况，小件无库存但是有生产准备费用
f1=(sum(X1.*[W(1);W(2);W(6);W(9)],1)+sum(X2.*[W(3:5)';W(7:8)';W(10:12)'],1))';
f2=(sum(X3.*C([1,2,6,9])',1)+sum(X4.*C([3,4,5,7,8,10,11,12])',1))';
F=sum(f1)+sum(f2);

function [F,f1,f2]=fun3(X,b,WPCR,A_x,B_x,C_x,W,C,D_x)
%初始化变量、计算目标函数值
X=reshape(X',212,4);
nn=2;
KC_WPCR=zeros(1,length(WPCR)+nn);%记录每天WPCR库存
KC=zeros(3,length(WPCR)+nn);%记录每天ABC库存
KC_x=zeros(8,length(WPCR)+nn);%记录每天ABC小件库存
SY_WPCR=zeros(1,length(WPCR)+nn);%记录每天交付WPCR情况
SY=zeros(3,length(WPCR)+nn);%记录每天使用ABC情况
% SY_x=zeros(8,length(WPCR)+nn);%记录每天使用ABC小件情况
SC_WPCR=zeros(1,length(WPCR)+nn);%记录每天组装WPCR情况
SC=zeros(3,length(WPCR)+nn);%记录每天生产ABC情况
SC_x=zeros(8,length(WPCR)+nn);%记录每天生产ABC小件情况
for i=1:length(WPCR)%循环遍历每个WPCR
    x=X(i,2:4);
    %更新SC、KC、SY矩阵
    %生产
    if length(find(b==i))==1
        SC_WPCR(i+nn)=0;
    else
        SC_WPCR(i+nn)=X(i,1);
    end
    if length(find(b==i-1))==1
        SC(:,i+nn-1)=0;
    else
        SC(:,i+nn-1)=SC(:,i+nn-1)+x';
    end
    %放库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn-1)+SC_WPCR(i+nn);
    if KC_WPCR(i+nn)<0
        KC_WPCR(i+nn)=0;
    end
    if i==1
        KC(:,i+nn-1)=SC(:,i+nn-1);
    else
        KC(:,i+nn-1)=KC(:,i+nn-1)+SC(:,i+nn-1);
    end
    KC_x(1:3,i+nn-2)=D_x(1:3).*SC(1,i+nn-1);
    KC_x(4:5,i+nn-2)=D_x(4:5).*SC(2,i+nn-1);
    KC_x(6:8,i+nn-2)=D_x(6:8).*SC(3,i+nn-1);
    %使用
    SY_WPCR(i+nn)=WPCR(i);
    SY(:,i+nn)=[A_x;B_x;C_x].*SY_WPCR(i+nn);
    %更新库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn)-WPCR(i);
    KC(:,i+nn)=KC(:,i+nn-1)-SY(:,i+nn);
end
X1=[SC_WPCR(:,nn+1:end-2);SC(:,nn+1:end-2)];%生产
X3=[KC_WPCR(:,nn+1:end-2);KC(:,nn+1:end-2)];%库存ABC
X4=[KC_x(:,nn+1:end-2)];%库存ABC小件
X1(find(X1>0))=1;
X2=[repmat(X1(2,:),3,1);repmat(X1(3,:),2,1);repmat(X1(4,:),3,1)];
X2(:,b)=0;
%最优情况，小件无库存但是有生产准备费用
f1=(sum(X1.*[W(1);W(2);W(6);W(9)],1)+sum(X2.*[W(3:5)';W(7:8)';W(10:12)'],1))';
f2=(sum(X3.*C([1,2,6,9])',1)+sum(X4.*C([3,4,5,7,8,10,11,12])',1))';
F=sum(f1)+sum(f2);

function J=jianyan3(X,b,WPCR,A_x,B_x,C_x,D_x)
%检验变量参与运算后是否出现小于0的值，是则不满足条件
X=X';
nn=2;
KC_WPCR=zeros(1,length(WPCR)+nn);%记录每天WPCR库存
KC=zeros(3,length(WPCR)+nn);%记录每天ABC库存
KC_x=zeros(8,length(WPCR)+nn);%记录每天ABC小件库存
SY_WPCR=zeros(1,length(WPCR)+nn);%记录每天交付WPCR情况
SY=zeros(3,length(WPCR)+nn);%记录每天使用ABC情况
SY_x=zeros(8,length(WPCR)+nn);%记录每天使用ABC小件情况
SC_WPCR=zeros(1,length(WPCR)+nn);%记录每天组装WPCR情况
SC=zeros(3,length(WPCR)+nn);%记录每天生产ABC情况
SC_x=zeros(8,length(WPCR)+nn);%记录每天生产ABC小件情况
for i=1:length(WPCR)%循环遍历每个WPCR
    x=X(i,2:4);
    %更新SC、KC、SY矩阵
    %生产
    if length(find(b==i))==1
        SC_WPCR(i+nn)=0;
    else
        SC_WPCR(i+nn)=X(i,1);
    end
    if length(find(b==i-1))==1
        SC(:,i+nn-1)=0;
    else
        SC(:,i+nn-1)=SC(:,i+nn-1)+x';
    end
    %放库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn-1)+SC_WPCR(i+nn);
    if KC_WPCR(i+nn)<0
        KC_WPCR(i+nn)=0;
    end
    if i==1
        KC(:,i+nn-1)=SC(:,i+nn-1);
    else
        KC(:,i+nn-1)=KC(:,i+nn-1)+SC(:,i+nn-1);
    end
    KC_x(1:3,i+nn-2)=D_x(1:3).*SC(1,i+nn-1);
    KC_x(4:5,i+nn-2)=D_x(4:5).*SC(2,i+nn-1);
    KC_x(6:8,i+nn-2)=D_x(6:8).*SC(3,i+nn-1);
    %使用
    SY_WPCR(i+nn)=WPCR(i);
    SY(:,i+nn)=[A_x;B_x;C_x].*SY_WPCR(i+nn);
    %更新库存
    KC_WPCR(i+nn)=KC_WPCR(i+nn)-WPCR(i);
    KC(:,i+nn)=KC(:,i+nn-1)-SY(:,i+nn);
end
if length(find(KC_WPCR<0))>0 | length(find(KC<0))>0 | length(find(KC_x<0))>0
    J=1;
else
    J=0;
end

8. Établissement et solution du modèle du quatrième problème

8.1 L'établissement des quatre modèles du problème

8.1.1 Analyse des données

Cette question doit prédire la demande d'utilisation des robots au cours de la 31e semaine. Selon l'analyse des données fournie par la question, la fluctuation des données a une certaine périodicité et il s'agit de données de séries chronologiques. Il n'y a qu'une seule variable dépendante : la nombre de robots utilisés. Ensuite, avec le nombre de robots utilisé comme variable dépendante, un modèle de prédiction de la demande des robots basé sur une analyse de séries temporelles univariées est établi.

Étant donné que les données avec des semaines comme variable de temps ne donnent pas une période spécifique, envisagez de diviser les données en un groupe d'entraînement et un groupe expérimental, utilisez différentes durées de période pour modéliser le groupe d'entraînement, filtrez les modèles qui réussissent le test Q, et puis utilisez les données du groupe expérimental. Les données déterminent quel modèle prédit le mieux. Sélectionnez le modèle avec la plus petite erreur de prédiction, utilisez toutes les données pour remodeler et faites des prédictions sur les données futures. Enfin, dessinez le diagramme de la série chronologique prévue pour juger si la tendance prévue est raisonnable.

8.1.2 Prétraitement des données

Données d'observation pendant 30 semaines et 201 jours, sans données manquantes. Définissez une variable de temps en semaines, dessinez un graphique de série chronologique avec le temps comme axe horizontal et le nombre de robots comme axe vertical. Analysez le graphique de la série chronologique et constatez que les données fluctuent de haut en bas dans une certaine plage, sans tendance ni saisonnalité.

8.1.3 Etablissement d'un modèle de prédiction basé sur des séries temporelles univariées

Les données du groupe de formation sont une séquence avec une longueur de cycle de 7, et le modèle d'analyse de série chronologique optimal est établi à l'aide du modélisateur expert SPSS. Le modélisateur expert trouve automatiquement le modèle le mieux adapté pour chaque séquence dépendante. Si une variable indépendante (prédictive) est spécifiée, le modélisateur expert sélectionne pour le contenu du modèle ARIMA les modèles qui ont une relation statistiquement significative avec la série dépendante. Les variables du modèle ont été transformées à l'aide de transformations de différence ou de racine carrée ou de logarithme naturel, selon le cas. Par défaut, le modélisateur expert considère à la fois les modèles de lissage exponentiel et ARIMA. Cependant, il est également possible de limiter l'Expert Modeler pour rechercher uniquement des modèles ARIMA ou uniquement des modèles de lissage exponentiel. Vous pouvez également spécifier la détection automatique des valeurs aberrantes.

Le sPSS Expert Modeler a automatiquement choisi le modèle optimal pour nous : le modèle saisonnier simple.

8.1.4 Test des modèles prédictifs

Vérifiez si le modèle est complètement reconnu : après avoir estimé le modèle de série temporelle, nous devons effectuer un test de bruit blanc sur le résidu. Si le résidu est un bruit blanc, cela signifie que le modèle que nous avons sélectionné peut identifier complètement la loi de la série temporelle. , c'est-à-dire que le modèle est acceptable. ; Si le résidu n'est pas un bruit blanc, cela signifie qu'il reste encore des informations non reconnues par le modèle, alors elles seront éliminées.

Le coefficient d'autocorrélation ACF et la fonction d'autocorrélation partielle PACF peuvent nous aider à déterminer si le résidu est un bruit blanc, c'est-à-dire si la série chronologique peut être entièrement reconnue par le modèle.

Comme on peut le voir dans le tableau ci-dessus, la valeur p obtenue par le test Q sur les résidus est de 0,451, c'est-à-dire que nous ne pouvons pas rejeter l'hypothèse nulle et penser que les résidus sont des séquences de bruit blanc, donc le modèle saisonnier simple peut bien identifier le robot dans cette question demander des données.

Comparaison et sélection de modèles : Utiliser les critères stationnaires R ² ou AIC et BIC. R ² peut être utilisé pour refléter la qualité de l'ajustement du modèle linéaire, plus il est proche de 1, plus l'ajustement est précis. Plus on ajoute de paramètres, meilleur est l'effet d'ajustement du modèle, mais cela se fait au prix d'une augmentation de la complexité du modèle (problème de surajustement). Par conséquent, la sélection du modèle recherche le meilleur équilibre entre la complexité du modèle et la capacité du modèle à interpréter les données. Étant donné que BIC a un coefficient de pénalité plus important pour la complexité du modèle, BIC est souvent plus concis que le modèle sélectionné par AIC, d'où le principe de choisir un petit R ² et BIC comme paramètres de sélection du modèle.

L'expression BIC (Bayesian Information Criterion) est la suivante :

$$BjeC=ln\left(T\right)(nombre\; de\; paramètres\; dans\; le\; modèle)-2ln(fonction\; de\; vraisemblance\; maximale\; du\; modèle)\text{\hspace{1em}( 41 )}$$

Obtenez les valeurs prédites pour la semaine 31 : 38, 35, 39, 40, 37, 34, 40. Valeurs prédites pour les deux premiers jours de la semaine 32 : 38, 35. Par conséquent, obtenez la matrice de quantité de demande de robot le jour d'une semaine dans le futur, comme suit :
$$DWpredict\_=[38,35,39,40,37,34,40,38,35]\text{\hspace{1em}( 42 )}$$

8.1.5 Garantir une livraison normale tous les jours

Afin d'assurer que les commandes quotidiennes de robots soient livrées avec une probabilité supérieure à 95%, les contraintes sur le nombre de robots assemblés sont modifiées comme suit :

$$M{F}_{}+SW{\_}_{ré-}⩾DW{\_}_{prédict\_{}_{}}\times \mathrm{0,95}\text{\hspace{1em}( 43 )}$$

8.1.6 Garantir une livraison normale tout au long de la semaine

Afin de garantir que les commandes de robots pour toute la semaine puissent être livrées avec une probabilité supérieure à 85 %, les contraintes suivantes sont imposées :

$$\sum _{ré=1}M{F}_{}⩾\mathrm{0,85}\times \sum _{ré=1}DWpredict\_{}_{}\text{\hspace{1em}( 44 )}$$
Il convient de noter que les commandes quotidiennes ont été livrées avec une probabilité de plus de 95 %, et les commandes de robots de toute la semaine doivent être livrées avec une probabilité de plus de 85 %, c'est-à-dire l'équation (44) a été implicite dans l'équation (43). Par conséquent, il suffit d'assurer une livraison normale tous les jours, c'est-à-dire que la formule (43) peut être ignorée.

Neuf, la réponse standard officielle

1. Le résultat final de la première question

2. Le résultat final de la deuxième question

3. Le résultat final de la troisième question

4. Le résultat final de la quatrième question