算法——基于java的实现"/>
补充8 供应链中周转库存的的算法——基于java的实现
理论部分请参考下方链接：
第四部分 供应链库存的计划和管理(一)供应链的规模经济管理:周转库存
目录
1.经济订货批量
2.期望的订货批量与订货成本之间的关系
3.多产品分别订货和运输
4.多产品联合订货和运输
5.能力约束下的聚集
6.随订货批次变化的、选定的部分产品联合订货和运输
7.全部数量单位折扣
8.边际单位数量折扣
9.局部最优的订货批量对供应链的影响
10.设计合适的、基于批量的数量折扣
11.商业促销对订货批量的影响
12.零售商应该让渡多少折扣优惠
1.经济订货批量
MoonLight公司对收集的月需求为1000台。每次订货的固定成本、运输和收货成本为4000元。每台收集的成本为500元，零售商的年库存持有费率为20%，计算门店每次补货应订购多少手机。
public class EOQData {//年需求double demand = 12000;//每批订货成本double orderCost = 4000;//年库存持有成本费率double costRate = 0.2;//单位成本double costUnit = 500;
}
public class EOQ {private EOQData data;public EOQ(EOQData data) {this.data = data;}public void calculation(){double eoq = Math.pow(2*data.demand*data.orderCost/(data.costRate*data.costUnit),0.5);System.out.println("最优订货批量=" + eoq);double cycleStock = eoq/2;System.out.println("周转库存=" + cycleStock);double annualOrderNum = data.demand/eoq;System.out.println("年订货次数=" + annualOrderNum);double annualOICost = data.demand*data.orderCost/eoq + eoq*data.costRate*data.costUnit/2;System.out.println("年订货和库存持有成本=" + annualOICost);double averageFlowTime = eoq/(2*data.demand);System.out.println("平均流动时间=" + averageFlowTime);}
}
public class Test {public static void main(String[] args) {//1.经济订货批量EOQData eoqData = new EOQData();EOQ eoq = new EOQ(eoqData);eoq.calculation();}
}
运行结果如下：
2.期望的订货批量与订货成本之间的关系
MoonLight经历希望将最优订货批量从980台降到200台。若将200台的订货批量称为最优订货批量，每批订货成本应该降到多少。
public class Relation {private EOQData data;private double expectedNum;public Relation(EOQData data, double expectedNum) {this.data = data;this.expectedNum = expectedNum;}public void calculate(){double S = data.costRate*data.costUnit*Math.pow(expectedNum,2)/(2*data.demand);System.out.println("期望的订货成本:" + S);}
}
public class Test {public static void main(String[] args) {//2.期望的订货批量与订货成本之间的关系EOQData eoqData = new EOQData();Relation relation = new Relation(eoqData, 200);relation.calculate();}
}
运行结果如下:
3.多产品分别订货和运输
MoonLight销售三种不同的手机：手机L，手机M，手机H。三种手机的年需求分别为：L的年需求为=12000台，M的需求=1200台，H的年需求为=120台。单台电脑的成本均为500元。每次订货的固定运输成本为4000元。另外，订购并装载在同一辆卡车上运送的每种型号电脑都会因为收货和储存而产生额外的固定成本1000元。本公司的年库存持有成本费率为20%。如果每种产品分别订货和运输，计算MoonLight的经营者应当选择的订货批量，同时计算上述订货策略下的年成本。
public class MutiData {//三种产品的需求double[] demands = {12000,1200,120};//三种产品的固定运输成本double[] transportCost = {4000,4000,4000};//三种产品的额外成本double[] additionalCost = {1000,1000,1000};//三种产品的单位成本double[] costUnit = {500,500,500};//三种产品的年库存持有成本费率double[] costRate = {0.2,0.2,0.2};int period = demands.length;
}
import java.util.Arrays;public class MutiSplitModel {private MutiData data;public MutiSplitModel(MutiData mutiData) {this.data = mutiData;}public void calculate(){double[] orderCost = new double[data.period];for (int i = 0; i < data.period; i++) {orderCost[i] = data.transportCost[i]+data.additionalCost[i];}System.out.println("固定成本:"+Arrays.toString(orderCost));double[] eoqs = new double[data.period];for (int i = 0; i < data.period; i++) {eoqs[i] = Math.pow(2*data.demands[i]*orderCost[i]/(data.costRate[i]*data.costUnit[i]),0.5);}System.out.println("最优订货批量:"+Arrays.toString(eoqs));double[] cycleStocks = new double[data.period];for (int i = 0; i < data.period; i++) {cycleStocks[i] = eoqs[i]/2;}System.out.println("周转库存:" + Arrays.toString(cycleStocks));double[] annualHoldingCosts = new double[data.period];for (int i = 0; i < data.period; i++) {annualHoldingCosts[i] = eoqs[i]*data.costRate[i]*data.costUnit[i]/2;}System.out.println("年库存持有成本:" + Arrays.toString(annualHoldingCosts));double[] annualOrderNums = new double[data.period];for (int i = 0; i < data.period; i++) {annualOrderNums[i] = data.demands[i]/eoqs[i];}System.out.println("订货频率:" + Arrays.toString(annualOrderNums));double[] annualOrderingCosts = new double[data.period];for (int i = 0; i < data.period; i++) {annualOrderingCosts[i] = data.demands[i]*orderCost[i]/eoqs[i];}System.out.println("年订货成本:" + Arrays.toString(annualOrderingCosts));double[] averageFlowTimes = new double[data.period];for (int i = 0; i < data.period; i++) {averageFlowTimes[i] = eoqs[i]/(2*data.demands[i]);}System.out.println("平均流动时间:" + Arrays.toString(averageFlowTimes));double[] annualCosts = new double[data.period];for (int i = 0; i < data.period; i++) {annualCosts[i] = annualHoldingCosts[i] + annualOrderingCosts[i];}System.out.println("年总成本:" + Arrays.toString(annualCosts));double totalCost = 0;for (int i = 0; i < data.period; i++) {totalCost += annualCosts[i];}System.out.println("所有产品年订货和库存持有成本:" + totalCost);}
}
public class Test {public static void main(String[] args) {//3.多产品分别订货和运输MutiData mutiData = new MutiData();MutiSplitModel mutiModel = new MutiSplitModel(mutiData);mutiModel.calculate();}
}
运行结果如下：
4.多产品联合订货和运输
当前主管决定在每次订货时联合订购三种型号产品，计算每种型号产品的最优订货批量。
import java.util.Arrays;public class MutiUniteModel {private MutiData data;public MutiUniteModel(MutiData data) {this.data = data;}public void calculate(){double orderCost = Arrays.stream(data.transportCost).max().getAsDouble();for (int i = 0; i < data.period; i++) {orderCost += data.additionalCost[i];}System.out.println("联合订货成本:" + orderCost);double tempVariable = 0;for (int i = 0; i < data.period; i++) {tempVariable += data.demands[i]*data.costRate[i]*data.costUnit[i];}double optimalOrderNum = Math.pow(tempVariable/(2*orderCost),0.5);System.out.println("最优订货频率:" + optimalOrderNum);double[] eoqs = new double[data.period];for (int i = 0; i < data.period; i++) {eoqs[i] = data.demands[i]/optimalOrderNum;}System.out.println("最优订货批量:" + Arrays.toString(eoqs));double[] cycleStocks = new double[data.period];for (int i = 0; i < data.period; i++) {cycleStocks[i] = eoqs[i]/2;}System.out.println("周转库存:" + Arrays.toString(cycleStocks));double[] annualHoldingCosts = new double[data.period];for (int i = 0; i < data.period; i++) {annualHoldingCosts[i] = eoqs[i]*data.costRate[i]*data.costUnit[i]/2;}System.out.println("年库存持有成本:" + Arrays.toString(annualHoldingCosts));double[] averageFlowTimes = new double[data.period];for (int i = 0; i < data.period; i++) {averageFlowTimes[i] = eoqs[i]/(2*data.demands[i]);}System.out.println("平均流动时间:" + Arrays.toString(averageFlowTimes));double annualOrderingCost = orderCost*optimalOrderNum;System.out.println("年订货成本:" + annualOrderingCost);double totalCost = annualOrderingCost;for (int i = 0; i < data.period; i++) {totalCost += annualHoldingCosts[i];}System.out.println("所有产品年订货和库存持有成本" + totalCost);}
}
public class Test {public static void main(String[] args) {//4.多产品联合订货和运输MutiData mutiData = new MutiData();MutiUniteModel mutiUniteModel = new MutiUniteModel(mutiData);mutiUniteModel.calculate();}
}
运行结果如下：
5.能力约束下的聚集
MoonLight公司有数百家供应商，正考虑通过集中内向运输降低成本。一卡车货物的运输成本为500元，装货成本为100元。对每个供应商的平均年需求均为10000单位货物。货物的单位成本为50元，年库存持有成本费率为20%。如果公司决定将每4家的供应商的货物集中在一辆卡车上运输，那么最优订货批量和最优订货频率分别为多少？若每辆卡车的装载能力为2500单位货物，那么最优订货批量和最优订货频率又为多少？
public class MutiConstrainData {//产品的需求double[] demands = {10000,10000,10000,10000};//固定运输成本double[] transportCost = {500,500,500,500};//额外成本double[] additionalCost = {100,100,100,100};//单位成本double[] costUnit = {50,50,50,50};//年库存持有成本费率double[] costRate = {0.2,0.2,0.2,0.2};//卡车装载能力double carCapacity = 2500;int period = demands.length;
}
import java.util.Arrays;public class MutiConstraintModel {private MutiConstrainData data;public MutiConstraintModel(MutiConstrainData data) {this.data = data;}public void calculate(){double orderCost = Arrays.stream(data.transportCost).max().getAsDouble();for (int i = 0; i < data.period; i++) {orderCost += data.additionalCost[i];}System.out.println("联合订货成本:" + orderCost);double tempVariable = 0;for (int i = 0; i < data.period; i++) {tempVariable += data.demands[i]*data.costRate[i]*data.costUnit[i];}double optimalOrderNum = Math.pow(tempVariable/(2*orderCost),0.5);System.out.println("最优订货频率:" + optimalOrderNum);double[] eoqs = new double[data.period];for (int i = 0; i < data.period; i++) {eoqs[i] = data.demands[i]/optimalOrderNum;}System.out.println("最优订货批量:" + Arrays.toString(eoqs));double annualOrderingCostPer = orderCost*optimalOrderNum/data.period;System.out.println("每个产品年订货成本:" + annualOrderingCostPer);double requiredCapacity = 0;for (int i = 0; i < data.period; i++) {requiredCapacity += eoqs[i];}System.out.println("要求装载能力:" + requiredCapacity);if(requiredCapacity>data.carCapacity){double assuranceCapability = data.carCapacity/data.period;System.out.println("总满载的情况下每产品的订货量:" + assuranceCapability);double totalDemands = 0;for (int i = 0; i < data.period; i++) {totalDemands += data.demands[i];}double revisedEoq = totalDemands/data.period/assuranceCapability;System.out.println("满足装载能力的订货频次：" + revisedEoq);}}
}
public class Test {public static void main(String[] args) {//5.能力约束下的聚集MutiConstrainData mutiConstrainData = new MutiConstrainData();MutiConstraintModel mutiConstraintModel = new MutiConstraintModel(mutiConstrainData);mutiConstraintModel.calculate();}
}
运行结果如下：
6.随订货批次变化的、选定的部分产品联合订货和运输
产品主管决定联合订货，但对于每次订货中包含哪些产品将有所选择。请制订订货策略并计算成本。
public class MutiData {//三种产品的需求double[] demands = {12000,1200,120};//三种产品的固定运输成本double[] transportCost = {4000,4000,4000};//三种产品的额外成本double[] additionalCost = {1000,1000,1000};//三种产品的单位成本double[] costUnit = {500,500,500};//三种产品的年库存持有成本费率double[] costRate = {0.2,0.2,0.2};int period = demands.length;
}
import java.util.*;
import java.util.stream.IntStream;public class MutiSelectModel {private MutiData data;public MutiSelectModel(MutiData data) {this.data = data;}public void calculate(){/*步骤一:找出每种产品单独订货时订货频率最高的产品*/double[] orderCost = new double[data.period];for (int i = 0; i < data.period; i++) {orderCost[i] = data.transportCost[i]+data.additionalCost[i];}double[] tempEoqs = new double[data.period];for (int i = 0; i < data.period; i++) {tempEoqs[i] = Math.pow(2*data.demands[i]*orderCost[i]/(data.costRate[i]*data.costUnit[i]),0.5);}double[] annualOrderNums = new double[data.period];for (int i = 0; i < data.period; i++) {annualOrderNums[i] = data.demands[i]/tempEoqs[i];}System.out.println("单独订货时的最优订货频率:" + Arrays.toString(annualOrderNums));List<Map> maxValue = getDoubleArrayMax(annualOrderNums);double maxOrderNum = (double) maxValue.get(0).get("max");System.out.println("订货频率最高:" + maxOrderNum);int maxIndex = (int) maxValue.get(1).get("index");System.out.println("订货频率最高产品的索引:" + maxIndex);/*步骤二：对于所有不等于maxIndex的产品，计算期望订货频率。*/double[] otherOrderNums = getNewArrayByDelIndex(annualOrderNums,maxIndex);double[] otherCostRates = getNewArrayByDelIndex(data.costRate,maxIndex);double[] otherCostUnits = getNewArrayByDelIndex(data.costUnit,maxIndex);double[] otherDemands = getNewArrayByDelIndex(data.demands,maxIndex);double[] otherAdditionalCosts = getNewArrayByDelIndex(data.additionalCost,maxIndex);double[] expectedOrderNums = new double[otherOrderNums.length];for (int i = 0; i < otherOrderNums.length; i++) {expectedOrderNums[i] = Math.pow(otherCostRates[i]*otherCostUnits[i]*otherDemands[i]/(2*otherAdditionalCosts[i]),0.5);}System.out.println("期望订货频率" + Arrays.toString(expectedOrderNums));/*步骤三：计算不等于maxIndex的产品与maxIndex每隔几次一起订购*/double[] intervalOrderNums = new double[otherOrderNums.length];for (int i = 0; i < otherOrderNums.length; i++) {intervalOrderNums[i] = Math.ceil(maxOrderNum/expectedOrderNums[i]);}System.out.println("间歇次数:" + Arrays.toString(intervalOrderNums));/*步骤四：确定每种不等于maxIndex产品的订货频率后，重新计算maxIndex的订货频率*/double[] allOrderNums = insertDoubleArrayByIndex(intervalOrderNums,0,1);double tempVarTop = 0;double tempVar1 = 0;for (int i = 0; i < data.period; i++) {tempVarTop += data.costRate[i]*data.costUnit[i]*allOrderNums[i]*data.demands[i];tempVar1 += data.additionalCost[i]/allOrderNums[i];}double tempVarBom = 2*(Arrays.stream(data.transportCost).max().getAsDouble() + tempVar1);double reMaxOrderNum = Math.pow(tempVarTop/tempVarBom,0.5);System.out.println("最高订货频率产品的订货频率:" + reMaxOrderNum);/*步骤五:计算每一种产品的最终订货频率和总成本*/double[] finalOrderNums = new double[data.period];for (int i = 0; i < data.period; i++) {finalOrderNums[i] = reMaxOrderNum/allOrderNums[i];}System.out.println("订货频率:"+Arrays.toString(finalOrderNums));double[] finalEoqs = new double[data.period];for (int i = 0; i < data.period; i++) {finalEoqs[i] = data.demands[i]/finalOrderNums[i];}System.out.println("订货批量:" + Arrays.toString(finalEoqs));double[] cycleStocks = new double[data.period];for (int i = 0; i < data.period; i++) {cycleStocks[i] = finalEoqs[i]/2;}System.out.println("周转库存:" + Arrays.toString(cycleStocks));double[] annualHoldingCosts = new double[data.period];for (int i = 0; i < data.period; i++) {annualHoldingCosts[i] = finalEoqs[i]*data.costRate[i]*data.costUnit[i]/2;}System.out.println("年库存持有成本:" + Arrays.toString(annualHoldingCosts));double[] averageFlowTimes = new double[data.period];for (int i = 0; i < data.period; i++) {averageFlowTimes[i] = finalEoqs[i]/(2*data.demands[i]);}System.out.println("平均流动时间:" + Arrays.toString(averageFlowTimes));double[] annualOrderingCosts = new double[data.period];for (int i = 0; i < data.period; i++) {annualOrderingCosts[i] += finalOrderNums[i]*data.additionalCost[i];}double toalOrderingCost = reMaxOrderNum*Arrays.stream(data.transportCost).max().getAsDouble() + Arrays.stream(annualOrderingCosts).sum();System.out.println("年订货成本:" + toalOrderingCost);double totalCost = Arrays.stream(annualHoldingCosts).sum() + toalOrderingCost;System.out.println("年总成本:" + totalCost);}//获取double数组的最大值及索引public List<Map> getDoubleArrayMax(double[] doubleArr){double[] copyArr = doubleArr.clone();Map<String,Double> map = new HashMap<>();map.put("max",copyArr[0]);Map<String,Integer> map1 = new HashMap<>();map1.put("index",0);for (int i = 0; i < copyArr.length; i++) {if(copyArr[i]>map.get("max")){map.put("max",copyArr[i]);map1.put("index",i);}}ArrayList<Map> listMap = new ArrayList<>();listMap.add(map);listMap.add(map1);return listMap;}//根据索引删除值后返回数组public double[] getNewArrayByDelIndex(double[] doubleArr,int index){double[] copyArr = doubleArr.clone();double[] newArr = new double[doubleArr.length-1];for (int i = index; i < doubleArr.length - 1; i++) {copyArr[i] = copyArr[i+1];}for (int i = 0; i < newArr.length; i++) {newArr[i] = copyArr[i];}return newArr;}//根据索引在数组中插入元素public double[] insertDoubleArrayByIndex(double[] doubleArr,int index,double element){double[] copyArr = doubleArr.clone();double[] newArr = new double[doubleArr.length+1];for (int i = 0; i < index; i++) {newArr[i] = copyArr[i];}newArr[index] = element;for (int i = index; i < doubleArr.length; i++) {newArr[i+1] = copyArr[i];}return newArr;}
}
public class Test {public static void main(String[] args) {//6.随订货批次变化的、选定的部分产品联合订货和运输MutiData mutiData = new MutiData();MutiSelectModel mutiSelectModel = new MutiSelectModel(mutiData);mutiSelectModel.calculate();}
}
运行结果如下：
7.全部数量单位折扣
MoonLight是一家在线销售处方药和营养品的零售商。阿司匹林在销售中占有相当高的比例。阿司匹林的月需求为10000瓶。该公司每次向制造商订购阿司匹林的固定订货成本、运输成本和收货成本为100元。该公司的年库存持有成本费率为20%。制造商使用以下全部单位数量折扣的定价方案。计算该公司每次应该订购多少瓶阿司匹林？
| 订货批量(瓶) | 单位价格(元) |
| 0~4999 | 3.00 |
| 5000~9999 | 2.96 |
| 10000或以上 | 2.92 |
public class DiscountData {//订货批量的分割点double[] splitOrderNums = {0,5000,10000};//单位价格/边际单位价格double[] splitPrices = {3,2.96,2.92};//年需求double demand = 120000;//每批订货成本double orderCost = 100;//年库存持有成本费率double costRate = 0.2;
}
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;public class AllDiscountModel {private DiscountData data;public AllDiscountModel(DiscountData data) {this.data = data;}public void calculate(){/*步骤一:计算每个价格下的经济订货批量*/double[] eoqsPerPrices = new double[data.splitOrderNums.length];for (int i = 0; i < data.splitOrderNums.length; i++) {eoqsPerPrices[i] = Math.pow(2*data.demand*data.orderCost/(data.costRate*data.splitPrices[i]),0.5);}System.out.println(Arrays.toString(eoqsPerPrices));/*步骤二:选择每一价格下的订货批量*/Map<Double, Double> eoqSelected = new HashMap<>();System.out.println(Arrays.toString(data.splitPrices));for (int i = 0; i < eoqsPerPrices.length; i++) {Double lowerEoq = data.splitOrderNums[i];Double higherEoq = i>eoqsPerPrices.length-2?Double.MAX_VALUE:data.splitOrderNums[i+1];Double nowEoq = eoqsPerPrices[i];if(lowerEoqpareTo(nowEoq)<=0&&higherEoqpareTo(nowEoq)>0){eoqSelected.put(data.splitPrices[i],nowEoq);} else if(nowEoqpareTo(lowerEoq)<0){eoqSelected.put(data.splitPrices[i],lowerEoq);}}for (Map.Entry entry:eoqSelected.entrySet()){System.out.println("价格:" + entry.getKey() +"--"+ "订货批量:" + entry.getValue());}/*步骤三:计算总成本*/Map<Double, Double> TCMap = new HashMap<>();for (Map.Entry<Double,Double> entry:eoqSelected.entrySet()){double tc = data.demand*data.orderCost/entry.getValue() + entry.getValue()*data.costRate*entry.getKey()/2+data.demand*entry.getKey();TCMap.put(entry.getKey(),tc);}double minTC = Double.MAX_VALUE;double finalPrice = 0;for (Map.Entry<Double,Double> entry:TCMap.entrySet()){System.out.println("价格:" + entry.getKey() + ", 总成本 = " + entry.getValue());if(entry.getValue() < minTC){minTC = entry.getValue();finalPrice = entry.getKey();}}System.out.println("最小的总成本："+minTC);System.out.println("最终的订货价格："+finalPrice);System.out.println("最终的eoq："+eoqSelected.get(finalPrice));}
}
public class Test {public static void main(String[] args) {//7.全部数量折扣DiscountData discountData = new DiscountData();AllDiscountModel allDiscountModel = new AllDiscountModel(discountData);allDiscountModel.calculate();}
}
运行结果如下：
8.边际单位数量折扣
假设制造商采用以下边际单位数量折扣定价方案：
| 订货批量(瓶) | 边际单位价格(元) |
| 0~4999 | 3.00 |
| 5000~9999 | 2.96 |
| 10000或以上 | 2.92 |
这意味着如果订购7000瓶阿司匹林，前5000瓶的单位成本为3.00元，余下2000瓶的单位成本为2.96元。MoonLight公司每批应该订购多少瓶阿司匹林？
public class DiscountData {//订货批量的分割点double[] splitOrderNums = {0,5000,10000};//单位价格/边际单位价格double[] splitPrices = {3,2.96,2.92};//年需求double demand = 120000;//每批订货成本double orderCost = 100;//年库存持有成本费率double costRate = 0.2;
}
import java.util.Arrays;public class LimitDiscountModel {private DiscountData data;public LimitDiscountModel(DiscountData data) {this.data = data;}public void calculate(){/*步骤一：计算每一价格下的订货批量*/double[] limitCosts = new double[data.splitPrices.length];limitCosts[0] = 0;for (int i = 0; i < data.splitPrices.length - 1 ; i++) {limitCosts[i+1] = 0;for (int j = 0; j < i+1; j++) {limitCosts[i+1] += (data.splitOrderNums[j+1] - data.splitOrderNums[j])*data.splitPrices[j];}}double[] eoqsPerPrices = new double[data.splitOrderNums.length];for (int i = 0; i < eoqsPerPrices.length; i++) {eoqsPerPrices[i] = Math.pow(2*data.demand*(data.orderCost+limitCosts[i]-data.splitOrderNums[i]*data.splitPrices[i])/(data.costRate*data.splitPrices[i]),0.5);}System.out.println("计算每一价格下的订货批量:" + Arrays.toString(eoqsPerPrices));/*步骤二：选择每一价格下的订货批量*/double[] eoqSelected = new double[data.splitOrderNums.length];for (int i = 0; i < eoqsPerPrices.length; i++) {Double lowerEoq = data.splitOrderNums[i];Double higherEoq = i>eoqsPerPrices.length-2?Double.MAX_VALUE:data.splitOrderNums[i+1];Double nowEoq = eoqsPerPrices[i];if(lowerEoqpareTo(nowEoq)<=0&&higherEoqpareTo(nowEoq)>0){eoqSelected[i] = nowEoq;} else if(lowerEoqpareTo(nowEoq)>0){eoqSelected[i] = lowerEoq;} else if(higherEoqpareTo(nowEoq)<0){eoqSelected[i] = higherEoq;}}System.out.println("选择每一价格下的订货批量:" + Arrays.toString(eoqSelected));/*步骤三:计算总成本*/double[] TCs = new double[eoqSelected.length];for (int i = 0; i < eoqSelected.length; i++) {TCs[i] = (data.demand/eoqSelected[i])*data.orderCost+(limitCosts[i]+(eoqSelected[i]-data.splitOrderNums[i])*data.splitPrices[i])*data.costRate/2+data.demand/eoqSelected[i]*(limitCosts[i]+(eoqSelected[i]-data.splitOrderNums[i])*data.splitPrices[i]);}System.out.println("总成本:" + Arrays.toString(TCs));int minIndex = 0;double minTC = Double.MAX_VALUE;for (int i = 0; i < TCs.length; i++) {if(TCs[i]<minTC){minIndex = i;minTC = TCs[i];}}System.out.println("最小成本为:" + minTC);System.out.println("最优订货批量为:" + eoqSelected[minIndex]);System.out.println("边际单位价格为:" + data.splitPrices[minIndex]);}
}
public class Test {public static void main(String[] args) {//8.边际数量折扣DiscountData discountData = new DiscountData();LimitDiscountModel limitDiscountModel = new LimitDiscountModel(discountData);limitDiscountModel.calculate();}
}
运行结果如下:
9.局部最优的订货批量对供应链的影响
每月阿司匹林的需求量为10000瓶。MoonLight公司每次向制造商订购阿司匹林的固定订货成本、运输成本、收获成本为100元。MoonLight的年库存持有成本费率为20%。制造商为每瓶阿司匹林定价3元。计算MoonLight的最优订货批量。
MoonLight每次订货，制造商都必须进行订单处理、包装和装运工作。制造商有一条生产线，以与需求相匹配的稳定速度装瓶。制造商的固定订单旅行成本为250元，每瓶阿司匹林的生产成本为2美元，年库存持有成本费率为20%。在MoonLight的订货策略下，制造商的年订单履行成本和库存持有成本为多少？
public class PartChainData {//年需求double demand = 120000;//订购成本double orderCost = 100;//年库存持有成本费率double costRate = 0.2;//定价double price = 3;//提供成本double supplyCost = 250;//年库存持有成本费率double supplierCostRate = 0.2;//生产成本double produceCost = 2;
}
public class PartChainModel {private PartChainData data;public PartChainModel(PartChainData data) {this.data = data;}public void calculate(){double eoq = Math.pow(2*data.demand*data.orderCost/(data.costRate*data.price),0.5);System.out.println("eoq:" + eoq);double customerTC = (data.demand/eoq)*data.orderCost+(eoq/2)*data.costRate*data.price;System.out.println("经销商总成本:" + customerTC);double supplierTC = (data.demand/eoq)*data.supplyCost+(eoq/2)*data.supplierCostRate*data.produceCost;System.out.println("供应商总成本:" + supplierTC);double totalTC = customerTC + supplierTC;System.out.println("供应链年成本:" + totalTC);}
}
public class Test {public static void main(String[] args) {//9.局部最优的订货批量对供应链的影响PartChainData partChainData = new PartChainData();PartChainModel partChainModel = new PartChainModel(partChainData);partChainModel.calculate();}
}
运行结果如下：
10.设计合适的、基于批量的数量折扣
相对与6325瓶为订货批量，以9165瓶为订货批量会使成本上升为264元。供应商需要降低为每瓶2.9978(3-264/120000)。对于供应商来说，对于MoonLight的合理的数量折扣为：小于9165，定价3元；大于9165，提供折扣价格2.9978。
11.商业促销对订货批量的影响
MoonLight公司是销售阿司匹林的零售商。阿司匹林的年需求为120000瓶。制造商目前每瓶的报价为3元，MoonLight的年库存持有成本费率为20%，目前的订货批量为6325瓶。接下来一个月，制造商将提供每瓶0.15元的折扣。在短期促销期间，MoonLight应购买多少阿司匹林？
public class PromotionForEoqData {double eoq = 6325;double demand = 120000;double discount = 0.15;double price = 3;double costRate = 0.2;
}
public class PromotionForEoqModel {private PromotionForEoqData data;public PromotionForEoqModel(PromotionForEoqData data) {this.data = data;}public void calculate(){double orderFrequency = 12/(data.demand/data.eoq);System.out.println("年订货频率" + orderFrequency);double cycleStock = data.eoq/2;System.out.println("周转库存=" + cycleStock);double averageFlowTime = data.eoq/(2*data.demand)*12;System.out.println("月平均流动时间=" + averageFlowTime);double eoqInDiscount = data.discount*data.demand/(data.price-data.discount)/data.costRate+ data.price*data.eoq/(data.price-data.discount);System.out.println("促销期间最优订货批量=" + eoqInDiscount);double cycleStockInDiscount = eoqInDiscount/2;System.out.println("促销期间周转库存="+cycleStockInDiscount);double averageFlowTimeInDiscount = eoqInDiscount/(2*data.demand)*12;System.out.println("月平均流动时间=" + averageFlowTimeInDiscount);double advancePurchaseNum = eoqInDiscount-data.eoq;System.out.println("提前购买量="+advancePurchaseNum);}
}
public class Test {public static void main(String[] args) {//10.商业促销对订货批量的影响PromotionForEoqData promotionForEoqData = new PromotionForEoqData();PromotionForEoqModel promotionForEoqModel = new PromotionForEoqModel(promotionForEoqData);promotionForEoqModel.calculate();}
}
运行结果如下：
12.零售商应该让渡多少折扣优惠
假如MoonLight的阿司匹林的需求曲线为300000-6000p，制造商向零售商的正常报价为3元/瓶，不考虑与库存的所有成本，MoonLight在制造商提供的短期折扣为0.15元/瓶的最优反应是什么？
public class ConcessionData {//需求曲线的斜率double slope = -60000;//截距double intercept = 300000;//报价double price = 3;//折扣double discount = 0.15;
}
public class ConcessionModel {private ConcessionData data;public ConcessionModel(ConcessionData data) {this.data = data;}public void calculate(){//假设需求曲线是线性的double p = (data.intercept - data.slope*data.price)/(-data.slope*2);System.out.println("最优零售价=" + p);double demand = data.intercept + data.slope*p;System.out.println("无促销活动市场需求=" + demand);double pInDisCount = (data.intercept - data.slope*(data.price-data.discount))/(-data.slope*2);System.out.println("有促销时最优零售价=" + pInDisCount);double demandInDisCount = data.intercept + data.slope*pInDisCount;System.out.println("有促销活动市场需求=" + demandInDisCount);}
}
public class Test {public static void main(String[] args) {//11.零售商应该让渡多少折扣优惠ConcessionData concessionData = new ConcessionData();ConcessionModel concessionModel = new ConcessionModel(concessionData);concessionModel.calculate();}
}
运行结果如下：
更多推荐
补充8 供应链中周转库存的的算法——基于java的实现
发布评论