package com.ryan.activity;
import java.util.LinkedList;
import java.util.List;
/**
* TASK基础类
*
* @author ryan
*/
public class Task {
private String taskNumber;//任务编号
private String logic;//任务之间的逻辑关系
private double earlyStartTime;//最早开始时间
private double earlyFinishTime;//最早结束时间
private double lateStartTime;//最晚开始时间
private double lateFinishTime;//最晚结束时间
private double dut;//执行时间
private double delayTime;//延迟时间
private double slack;//机动时间
private String[] logicArray;//任务之间的逻辑关系
private double[] earlyStartTimeArray;//最早开始时间
private double[] earlyFinishTimeArray;//最早结束时间
private double[] lateStartTimeArray;//最晚开始时间
private double[] lateFinishTimeArray;//最晚结束时间
private double[] dutArray;//执行时间
private double[] delayTimeArray;//延迟时间
private double[] slackArray;//机动时间
private boolean isCalEST = false;//是否计算了最早开始时间
private boolean isCalEFT = false;//是否计算了最早结束时间
private boolean isCalLST = false;//是否计算了最晚开始时间
private boolean isCalLFT = false;//是否计算了最晚结束时间
private boolean isCalSlack = false;//是否计算了机动时间
private boolean isCalETArray = false;//是否计算了最早开始时间
private boolean isCalLTArray = false;//是否计算了最晚开始时间
private boolean isCalSlackArray = false;//是否计算了机动时间
private boolean isCriticalPath = false;//是否是关键路径
private List previousTasks = new LinkedList();//前置任务集合
private List nextTasks = new LinkedList();//后置任务集合
/*
* 计算最早开始时间
*/
public void calculateET(){
if(!this.isCalEST()){
double est = 0.0d;//临时存放最早开始时间
boolean isTmp = false;//标记是否执行了逻辑关系中的代码
if(this.getPreviousTasks().size()==0){//第一个任务是没有前置任务的，所以其最早开始时间是0
this.earlyStartTime = est;
this.isCalEST = true;
} else {
if("FS".equals(logic)){//ES= max{ES(前)+ Dur(前)+ FTS}
for(Task previousTask : this.getPreviousTasks()){
if(previousTask.getEarlyFinishTime()>est && previousTask.isCalEFT()){
est = previousTask.getEarlyFinishTime();
isTmp = previousTask.isCalEFT();
}
}
est = est + this.getDelayTime();
}else if("FF".equals(logic)){//ES= max{ES(前)+ Dur(前) - Dur +FTF}
for(Task previousTask : this.getPreviousTasks()){
if(previousTask.getEarlyFinishTime()>est && previousTask.isCalEFT()){
est = previousTask.getEarlyFinishTime();
isTmp = previousTask.isCalEFT();
}
}
est = est + this.getDelayTime() - this.getDut();
}else if("SS".equals(logic)){//ES=max{ ES(前) + STS}
for(Task previousTask : this.getPreviousTasks()){
if(previousTask.getEarlyStartTime()>est && previousTask.isCalEST()){
est = previousTask.getEarlyStartTime();
isTmp = previousTask.isCalEST();
}
}
est = est + this.getDelayTime();
}else if("SF".equals(logic)){//ES=max{ ES(前) - Dur +STF}
for(Task previousTask : this.getPreviousTasks()){
if(previousTask.getEarlyStartTime()>est && previousTask.isCalEST()){
est = previousTask.getEarlyStartTime();
isTmp = previousTask.isCalEST();
}
}
est = est - this.getDut() + this.getDelayTime();
}
if(isTmp){
this.earlyStartTime = est;
this.isCalEST = true;
}
}
}
if(!this.isCalEFT() && this.isCalEST()){
this.earlyFinishTime = this.getEarlyStartTime() + this.getDut();
this.isCalEFT = true;
}
}
/*
*计算最晚时间
*/
public void calculateLT(){
if(!this.isCalLST()){
calculateLT(this.nextTasks,this);
}
if(!this.isCalLFT()){
calculateLT(this.nextTasks,this);
}
}
/*
* task的后置任务nextTasks
*/
public void calculateLT(List nextTasks,Task task){
double tmpSlack = 0.0d;//临时时间差
boolean isTmp = false;//标记
if(nextTasks.size()==0 ){
if(task.isCalEST() && task.isCalEFT()){
task.lateFinishTime = task.getEarlyFinishTime();
task.slack = 0.0d;
task.isCalLFT = true;
task.isCalSlack = true;
task.lateStartTime = task.getEarlyStartTime();
task.slack = 0.0d;
task.isCalLST = true;
task.isCalSlack = true;
}
} else{
for(int i = 0; i
Task nextTask = nextTasks.get(i);
if(!nextTask.isCalLFT())
return;
if(!nextTask.isCalLST())
return;
if(nextTask.isCalSlack){
double _tmp = tmpSlack;//临时时间间隔
if("FS".equals(nextTask.logic) && nextTask.isCalEST() && task.isCalEFT()){//Slack = min{slack后+ES后-EF-FTS}
_tmp = nextTask.getSlack() + nextTask.getEarlyStartTime() - task.getEarlyFinishTime() - nextTask.getDelayTime();
isTmp = true;
}else if("FF".equals(nextTask.logic) && nextTask.isCalEFT() && task.isCalEFT()){//Slack = min{slack后+EF后-EF-FTF}
_tmp = nextTask.getSlack() + nextTask.getEarlyFinishTime() - task.getEarlyFinishTime() - nextTask.getDelayTime();
isTmp = true;
}else if("SF".equals(nextTask.logic) && nextTask.isCalEFT() && task.isCalEST()){//Slack = min｛slack后+EF后-ES-STF｝
_tmp = nextTask.getSlack() + nextTask.getEarlyFinishTime() - task.getEarlyStartTime() - nextTask.getDelayTime();
isTmp = true;
}else if("SS".equals(nextTask.logic) && nextTask.isCalEST() && task.isCalEST()){//Slack = min{slack后+ES后-ES-STS}
_tmp = nextTask.getSlack() + nextTask.getEarlyStartTime() - task.getEarlyStartTime() - nextTask.getDelayTime();
isTmp = true;
}
if(i==0){
tmpSlack = _tmp;
}
if(_tmp < tmpSlack ){
tmpSlack = _tmp;
}
}
}
}
if(isTmp && task.isCalEST() && task.isCalEFT()){//isTmp标记为true，说明已经经过计算。
task.lateFinishTime = task.getEarlyFinishTime() + tmpSlack;
task.setSlack(tmpSlack);
task.isCalLFT = true;
task.isCalSlack = true;
task.lateStartTime = task.getEarlyStartTime() + tmpSlack;
task.setSlack(tmpSlack);
task.isCalLST = true;
task.isCalSlack = true;
}
}
/*
* 计算最早开始和最早结束时间
* */
public void calculateETArray(){
if(!this.isCalETArray()){
double[] dutArray = this.getDutArray();
double[] delayTimeArray = this.getDelayTimeArray();
String[] logicArray = this.getLogicArray();
double[] earlyStartTimeArray = new double[dutArray.length];
double[] earlyFinishTimeArray = new double[dutArray.length];
int ETCount = 0;
for (int i=0;i
this.setDelayTime(delayTimeArray[i]);
this.setLogic(logicArray[i]);
this.setDut(dutArray[i]);
this.calculateET();
earlyStartTimeArray[i] = this.getEarlyStartTime();
earlyFinishTimeArray[i] = this.getEarlyFinishTime();
ETCount++;
}
if(ETCount==dutArray.length){
this.setEarlyStartTimeArray(earlyStartTimeArray);
this.setEarlyFinishTimeArray(earlyFinishTimeArray);
this.setCalETArray(true);
}
}
}
/*
* 计算最晚开始和最晚结束时间
* */
public void calculateLTArray(){
if(!this.isCalLTArray()){
double[] dutArray = this.getDutArray();
double[] delayTimeArray = this.getDelayTimeArray();
String[] logicArray = this.getLogicArray();
double[] lateStartTimeArray = new double[dutArray.length];
double[] lateFinishTimeArray = new double[dutArray.length];
int LTCount = 0;
for (int i=0;i
this.setDelayTime(delayTimeArray[i]);
this.setLogic(logicArray[i]);
this.setDut(dutArray[i]);
this.calculateLT();
lateStartTimeArray[i] = this.getLateStartTime();
lateFinishTimeArray[i] = this.getLateFinishTime();
LTCount++;
}
if(LTCount==dutArray.length){
this.setLateStartTimeArray(lateStartTimeArray);
this.setLateFinishTimeArray(lateFinishTimeArray);
this.setCalLTArray(true);
}
}
}
/*
* taskNumber 任务编号
* logic 与前置任务的逻辑关系
* dut 任务执行时间
*delayTime 提前滞后时间
*/
public Task(String taskNumber,String logic, double dut, double delayTime) {
super();
this.taskNumber = taskNumber;
this.logic = logic;
this.dut = dut;
this.delayTime = delayTime;
}
/*
* taskNumber 任务编号
* logic 与前置任务的逻辑关系
* dut 任务执行时间数组
* delayTime 提前滞后时间数组
*/
public Task(String taskNumber,String[] logicArray, double[] dutArray, double[] delayTimeArray) {
super();
this.taskNumber = taskNumber;
this.logicArray = logicArray;
this.dutArray = dutArray;
this.delayTimeArray = delayTimeArray;
}
public String getTaskNumber() {
return taskNumber;
}
public void setTaskNumber(String taskNumber) {
this.taskNumber = taskNumber;
}
public double getDelayTime() {
return delayTime;
}
public void setDelayTime(double delayTime) {
this.delayTime = delayTime;
}
public double getDut() {
return dut;
}
public void setDut(double dut) {
this.dut = dut;
}
public double getEarlyFinishTime() {
return earlyFinishTime;
}
public double getEarlyStartTime() {
return earlyStartTime;
}
public double getLateFinishTime() {
return lateFinishTime;
}
public double getLateStartTime() {
return lateStartTime;
}
public double getSlack(){
return slack;
}
public void setSlack(double slack){
this.slack = slack;
}
public boolean isCalEST(){;
return isCalEST;
}
public boolean isCalEFT(){;
return isCalEFT;
}
public boolean isCalLST(){
return isCalLST;
}
public boolean isCalLFT(){
return isCalLFT;
}
public boolean isCriticalPath(){
return isCriticalPath;
}
public List getPreviousTasks() {
return previousTasks;
}
public String getLogic() {
return logic;
}
public void setLogic(String logic) {
this.logic = logic;
}
public void setPreviousTasks(List previousTasks) {
this.previousTasks = previousTasks;
for (Task task : this.previousTasks) {
task.getNextTasks().add(this);
}
}
public List getNextTasks() {
return nextTasks;
}
public void setNextTasks(List nextTasks) {
this.nextTasks = nextTasks;
}
public String[] getLogicArray() {
return logicArray;
}
public void setLogicArray(String[] logicArray) {
this.logicArray = logicArray;
}
public double[] getDelayTimeArray() {
return delayTimeArray;
}
public void setDelayTimeArray(double[] delayTimeArray) {
this.delayTimeArray = delayTimeArray;
}
public double[] getDutArray() {
return dutArray;
}
public void setDutArray(double[] dutArray) {
this.dutArray = dutArray;
}
public double[] getEarlyFinishTimeArray() {
return earlyFinishTimeArray;
}
public void setEarlyFinishTimeArray(double[] earlyFinishTimeArray) {
this.earlyFinishTimeArray = earlyFinishTimeArray;
}
public double[] getEarlyStartTimeArray() {
return earlyStartTimeArray;
}
public void setEarlyStartTimeArray(double[] earlyStartTimeArray) {
this.earlyStartTimeArray = earlyStartTimeArray;
}
public double[] getLateFinishTimeArray() {
return lateFinishTimeArray;
}
public void setLateFinishTimeArray(double[] lateFinishTimeArray) {
this.lateFinishTimeArray = lateFinishTimeArray;
}
public double[] getLateStartTimeArray() {
return lateStartTimeArray;
}
public void setLateStartTimeArray(double[] lateStartTimeArray) {
this.lateStartTimeArray = lateStartTimeArray;
}
public double[] getSlackArray() {
return slackArray;
}
public void setSlackArray(double[] slackArray) {
this.slackArray = slackArray;
}
public boolean isCalSlackArray() {
return isCalSlackArray;
}
public void setCalSlackArray(boolean isCalSlackArray) {
this.isCalSlackArray = isCalSlackArray;
}
public boolean isCalETArray() {
return isCalETArray;
}
public void setCalETArray(boolean isCalETArray) {
this.isCalETArray = isCalETArray;
}
public boolean isCalLTArray() {
return isCalLTArray;
}
public void setCalLTArray(boolean isCalLTArray) {
this.isCalLTArray = isCalLTArray;
}
public void setCriticalPath() {
if(this.isCalLST() && this.isCalEST()){
if(this.getLateStartTime()-this.getEarlyStartTime()==0)
this.isCriticalPath = true;
}
}
public void setCriticalPathArray() {
if(this.isCalLTArray() && this.isCalETArray()){
//TODO 待完成
}
}
}
还有一个封装测试类，利用随机数模拟蒙特卡洛模拟法(
http://baike.baidu.com/view/2692033.htm
)
package com.ryan.activity;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.Set;
/**
* Task的计算逻辑类
*
* @author ryan
*/
public class Wbs {
private List tasks;//所有任务集合
private Set noPreviousTasks;//没有前置任务的任务集合
private Set noNextTasks;//没有后置任务的任务集合
/**
* @param tasks 所有任务集合
* @return 没有前置任务的任务集合
*/
public Set getNoPreviousTasks(List tasks){
if(tasks!=null && tasks.size()>0){
for(Task task : tasks){
if(task!=null && task.getPreviousTasks().size()==0){
this.noPreviousTasks.add(task);
}
}
}
return this.noPreviousTasks;
}
/**
* @param tasks 所有任务集合
* @return 没有后置任务的任务集合
*/
public Set getNoNextTasks(List tasks){
if(tasks!=null && tasks.size()>0){
for(Task task : tasks){
if(task!=null && task.getNextTasks().size()==0){
this.noNextTasks.add(task);
}
}
}
return this.noNextTasks;
}
/**
* @param tasks 所有任务
* @return 没有前置任务计算完成之后，待计算的任务
*/
private Set calculateNoPreviousEarlyTime(List tasks){
//System.out.println("开始调用calculateNoPreviousEarlyTime(List tasks)------");
Set calTasks = new LinkedHashSet();
if(tasks!=null && tasks.size()>0){
Set noPreviousTasks = this.getNoPreviousTasks(tasks);
for(Task task : noPreviousTasks){
//System.out.println("没有前置任务的是"+task.getTaskNumber());
if(!task.isCalEST()&&!task.isCalEFT())
task.calculateET();
calTasks.add(task);
}
}
//System.out.println("结束调用calculateNoPreviousEarlyTime(List tasks)------");
return calTasks;
}
/**
* @param nextTasks 本次待计算的任务
* @return 下一次待计算的任务
*/
public Set calculateEarlyTime(Set nextTasks){
Set calTasks = new LinkedHashSet();
if(nextTasks!=null && nextTasks.size()>0){
Iterator it = nextTasks.iterator();
while(it.hasNext()){
Task task = it.next();
//System.out.println("本次需要计算的任务是"+task.getTaskNumber());
//找到本任务的前置任务看是不是全部计算完成了，
List befTask = task.getPreviousTasks();
//判断本任务的前置任务是不是完全计算完成的计数器
int count = 0;//计数器
for(int i=0;i
Task bfTask = befTask.get(i);
if(bfTask.isCalEST() && bfTask.isCalEFT())
count++;
}
//如果全部计算完成，将本任务的后置任务加入到返回列表里
if(count==befTask.size()){
task.calculateET();
//System.out.println("已经计算了"+task.getTaskNumber());
calTasks.addAll(task.getNextTasks());
//如果没有全部计算完成，把本任务加入到计算列表里
}else{
calTasks.add(task);
}
}
}
return calTasks;
}
/**
* @param tasks 所有任务
* @return 没有前置任务的下一层需要计算的任务
*/
public Set calNoNextTasksLateTime(List tasks){
Set calTasks = new LinkedHashSet();
if(tasks!=null && tasks.size()>0){
for (Task task : this.getNoNextTasks(tasks)) {
if(!task.isCalLST()&&!task.isCalLFT())
task.calculateLT();
calTasks.add(task);
}
}
return calTasks;
}
/**
* @param nextTasks 本次待计算的任务
* @return 下一次需要计算的任务
*/
public Set calculateLateTime(Set nextTasks){
Set calTasks = new LinkedHashSet();
if(nextTasks!=null && nextTasks.size()>0){
Iterator it = nextTasks.iterator();
while(it.hasNext()){
Task task = it.next();
//找到本任务的后置任务看是不是全部计算完成了，
List nextTask = task.getNextTasks();
//判断本任务的后置任务是不是完全计算完成的计数器
int count = 0;//计数器
for(int i=0;i
Task ntTask = nextTask.get(i);
if(ntTask.isCalLST()&&ntTask.isCalLFT())
count++;
}
//如果全部计算完成，将本任务的后置任务加入到返回列表里
if(count==nextTask.size()){
task.calculateLT();
//System.out.println("计算的是"+task.getTaskNumber());
calTasks.addAll(task.getPreviousTasks());
//如果没有全部计算完成，把本任务加入到计算列表里
}else{
calTasks.add(task);
}
}
}
return calTasks;
}
/*
* 计算最早最晚时间
*/
public void calculateTime() {
//计算没有前置任务的任务
Set firstTimes = calculateNoPreviousEarlyTime(this.tasks);
//依次分层计算后一层的任务EST，EFT
Set nextTimes = calculateEarlyTime(firstTimes);
Set tmpTasks;
do{
tmpTasks = nextTimes;
nextTimes = calculateEarlyTime(tmpTasks);
}while(nextTimes.size()>0);
firstTimes.clear();
nextTimes.clear();
tmpTasks.clear();
//计算没有后置任务的任务
firstTimes = calNoNextTasksLateTime(this.tasks);
//依次分层计算后一层的任务的LST
nextTimes = calculateLateTime(firstTimes);
do{
tmpTasks = nextTimes;
nextTimes = calculateLateTime(tmpTasks);
}while(nextTimes.size()>0);
//打印计算结果
for (Task task : this.tasks) {
System.out.println(task.getTaskNumber()+"tnumber=="+task.getEarlyStartTime()+"est==="+task.getEarlyFinishTime()+"eft==="+task.getLateStartTime()+"lst==="+task.getLateFinishTime()+"lft===="+task.isCriticalPath());
}
}
/**
* @param tasks 所有任务
* @return 没有前置任务计算完成之后，待计算的任务
*/
private Set calculateNoPreviousEarlyTimeArray(List tasks){
//System.out.println("开始调用calculateNoPreviousEarlyTime(List tasks)------");
Set calTasks = new LinkedHashSet();
if(tasks!=null && tasks.size()>0){
Set noPreviousTasks = this.getNoPreviousTasks(tasks);
for(Task task : noPreviousTasks){
//System.out.println("没有前置任务的是"+task.getTaskNumber());
if(!task.isCalETArray()){
task.calculateETArray();
System.out.println("计算了第一个"+task.getTaskNumber()+"tnumber=="+task.getEarlyStartTime()+"est==="+task.getEarlyFinishTime()+"eft===");
calTasks.add(task);
}
}
}
//System.out.println("结束调用calculateNoPreviousEarlyTime(List tasks)------");
return calTasks;
}
/**
* @param nextTasks 本次待计算的任务
* @return 下一次待计算的任务
*/
public Set calculateEarlyTimeArray(Set nextTasks){
Set calTasks = new LinkedHashSet();
if(nextTasks!=null && nextTasks.size()>0){
Iterator it = nextTasks.iterator();
while(it.hasNext()){
Task task = it.next();
//System.out.println("本次需要计算的任务是"+task.getTaskNumber());
//找到本任务的前置任务看是不是全部计算完成了，
List befTask = task.getPreviousTasks();
//判断本任务的前置任务是不是完全计算完成的计数器
int count = 0;//计数器
for(int i=0;i
Task bfTask = befTask.get(i);
if(bfTask.isCalETArray())
count++;
}
//如果全部计算完成，将本任务的后置任务加入到返回列表里
if(count==befTask.size()){
task.calculateETArray();
//System.out.println("已经计算了"+task.getTaskNumber());
calTasks.addAll(task.getNextTasks());
//如果没有全部计算完成，把本任务加入到计算列表里
}else{
calTasks.add(task);
}
}
}
return calTasks;
}
/**
* @param tasks 所有任务
* @return 没有前置任务的下一层需要计算的任务
*/
public Set calNoNextTasksLateTimeArray(List tasks){
Set calTasks = new LinkedHashSet();
if(tasks!=null && tasks.size()>0){
for (Task task : this.getNoNextTasks(tasks)) {
if(!task.isCalLTArray())
task.calculateLTArray();
calTasks.add(task);
}
}
return calTasks;
}
/**
* @param nextTasks 本次待计算的任务
* @return 下一次需要计算的任务
*/
public Set calculateLateTimeArray(Set nextTasks){
Set calTasks = new LinkedHashSet();
if(nextTasks!=null && nextTasks.size()>0){
Iterator it = nextTasks.iterator();
while(it.hasNext()){
Task task = it.next();
//找到本任务的后置任务看是不是全部计算完成了，
List nextTask = task.getNextTasks();
//判断本任务的后置任务是不是完全计算完成的计数器
int count = 0;//计数器
for(int i=0;i
Task ntTask = nextTask.get(i);
if(ntTask.isCalLTArray())
count++;
}
//如果全部计算完成，将本任务的后置任务加入到返回列表里
if(count==nextTask.size()){
task.calculateLTArray();
//System.out.println("计算的是"+task.getTaskNumber());
calTasks.addAll(task.getPreviousTasks());
//如果没有全部计算完成，把本任务加入到计算列表里
}else{
calTasks.add(task);
}
}
}
return calTasks;
}
/*
* 计算最早最晚时间
*/
public void calculateTimeArray() {
//计算没有前置任务的任务
Set firstTimes = calculateNoPreviousEarlyTimeArray(this.tasks);
//依次分层计算后一层的任务EST，EFT
Set nextTimes = calculateEarlyTimeArray(firstTimes);
Set tmpTasks;
do{
tmpTasks = nextTimes;
nextTimes = calculateEarlyTimeArray(tmpTasks);
}while(nextTimes.size()>0);
firstTimes.clear();
nextTimes.clear();
tmpTasks.clear();
//计算没有后置任务的任务
firstTimes = calNoNextTasksLateTimeArray(this.tasks);
//依次分层计算后一层的任务的LST
nextTimes = calculateLateTimeArray(firstTimes);
do{
tmpTasks = nextTimes;
nextTimes = calculateLateTimeArray(tmpTasks);
}while(nextTimes.size()>0);
//打印计算结果
for (int i =0; i
Task task = this.tasks.get(i);
System.out.println(task.getTaskNumber()+"tnumber=="+task.getEarlyStartTimeArray()[0]+"est==="+task.getEarlyFinishTimeArray()[0]+"eft==="+task.getLateStartTimeArray()[0]+"lst==="+task.getLateFinishTimeArray()[0]+"lft");
}
}
public List getTasks() {
return tasks;
}
public void setTasks(List tasks) {
this.tasks = tasks;
}
public Set getNoNextTasks() {
return getNoNextTasks(tasks);
}
public Set getNoPreviousTasks() {
return getNoPreviousTasks(tasks);
}
/*
* tasks 所有任务集合
*/
public Wbs(List tasks) {
super();
this.tasks = tasks;
this.noNextTasks = new LinkedHashSet();
this.noPreviousTasks = new LinkedHashSet();
}
public static void main(String args[]){
//String[] l1 = {"FS"};
//double[] d1 = {15};
//double[] dl1 = {0};
//Task t1 = new Task("1",l1,d1,dl1);
//String[] l2 = {"FS"};
//double[] d2 = {20};
//double[] dl2 = {-5};
//Task t2 = new Task("2",l2,d2,dl2);
//String[] l3 = {"FS"};
//double[] d3 = {26};
//double[] dl3 = {0};
//Task t3 = new Task("3",l3,d3,dl3);
//String[] l4 = {"SS"};
//double[] d4 = {18};
//double[] dl4 = {10};
//Task t4 = new Task("4",l4,d4,dl4);
//String[] l5 = {"FS"};
//double[] d5 = {15};
//double[] dl5 = {0};
//Task t5 = new Task("5",l5,d5,dl5);
//String[] l6 = {"FS"};
//double[] d6 = {38};
//double[] dl6 = {0};
//Task t6 = new Task("6",l6,d6,dl6);
//String[] l7 = {"FS"};
//double[] d7 = {25};
//double[] dl7 = {-5};
//Task t7 = new Task("7",l7,d7,dl7);
//String[] l8 = {"FS"};
//double[] d8 = {15};
//double[] dl8 = {5};
//Task t8 = new Task("8",l8,d8,dl8);
//String[] l9 = {"SS"};
//double[] d9 = {18};
//double[] dl9 = {20};
//Task t9 = new Task("9",l9,d9,dl9);
//String[] l10 = {"FS"};
//double[] d10 = {30};
//double[] dl10 = {0};
//Task t10 = new Task("10",l10,d10,dl10);
//String[] l11 = {"FS"};
//double[] d11 = {28};
//double[] dl11 = {5};
//Task t11 = new Task("11",l11,d11,dl11);
//String[] l12 = {"FS"};
//double[] d12 = {140};
//double[] dl12 = {0};
//Task t12 = new Task("12",l12,d12,dl12);
//String[] l13 = {"FS"};
//double[] d13 = {18};
//double[] dl13 = {-5};
//Task t13 = new Task("13",l13,d13,dl13);
//String[] l14 = {"SS"};
//double[] d14 = {20};
//double[] dl14 = {10};
//Task t14 = new Task("14",l14,d14,dl14);
//String[] l15 = {"FS"};
//double[] d15 = {15};
//double[] dl15 = {0};
//Task t15 = new Task("15",l15,d15,dl15);
//String[] l16 = {"FS"};
//double[] d16 = {33};
//double[] dl16 = {0};
//Task t16 = new Task("16",l16,d16,dl16);
//String[] l17 = {"FS"};
//double[] d17 = {8};
//double[] dl17 = {0};
//Task t17 = new Task("17",l17,d17,dl17);
//String[] l18 = {"FS"};
//double[] d18 = {15};
//double[] dl18 = {0};
//Task t18 = new Task("18",l18,d18,dl18);
//String[] l19 = {"FS"};
//double[] d19 = {17};
//double[] dl19 = {0};
//Task t19 = new Task("19",l19,d19,dl19);
//String[] l20 = {"FS"};
//double[] d20 = {25};
//double[] dl20 = {0};
//Task t20 = new Task("20",l20,d20,dl20);
//Task t1 = new Task("1","FS",15,0);
//Task t2 = new Task("2","FS",20,-5);
//Task t3 = new Task("3","FS",26,0);
//Task t4 = new Task("4","SS",18,10);
//Task t5 = new Task("5","FS",15,0);
//Task t6 = new Task("6","FS",38,0);
//Task t7 = new Task("7","FS",25,-5);
//Task t8 = new Task("8","FS",15,5);
//Task t9 = new Task("9","SS",18,20);
//Task t10 = new Task("10","FS",30,0);
//Task t11 = new Task("11","FS",28,5);
//Task t12 = new Task("12","FS",140,0);
//Task t13 = new Task("13","FS",18,-5);
//Task t14 = new Task("14","SS",20,10);
//Task t15 = new Task("15","FS",15,0);
//Task t16 = new Task("16","FS",33,0);
//Task t17 = new Task("17","FS",8,0);
//Task t18 = new Task("18","FS",15,0);
//Task t19 = new Task("19","FS",17,0);
//Task t20 = new Task("20","FS",25,0);
//
//List tl1 = new LinkedList();
//List tl2 = new LinkedList();
//List tl3 = new LinkedList();
//List tl4 = new LinkedList();
//List tl5 = new LinkedList();
//List tl6 = new LinkedList();
//List tl7 = new LinkedList();
//List tl8 = new LinkedList();
//List tl9 = new LinkedList();
//List tl10 = new LinkedList();
//List tl11 = new LinkedList();
//List tl12 = new LinkedList();
//List tl13 = new LinkedList();
//List tl14 = new LinkedList();
//
//List tl = new LinkedList();
//
//tl1.add(t1);
//tl2.add(t2);
//tl3.add(t4);
//tl4.add(t6);
//tl5.add(t3);
//tl5.add(t5);
//tl6.add(t7);
//tl6.add(t8);
//tl6.add(t9);
//tl7.add(t10);
//tl8.add(t12);
//tl9.add(t13);
//tl10.add(t14);
//tl11.add(t11);
//tl11.add(t15);
//tl12.add(t16);
//tl13.add(t17);
//tl14.add(t18);
//tl14.add(t19);
//
//tl.add(t1);
//tl.add(t2);
//tl.add(t3);
//tl.add(t4);
//tl.add(t5);
//tl.add(t6);
//tl.add(t7);
//tl.add(t8);
//tl.add(t9);
//tl.add(t10);
//tl.add(t11);
//tl.add(t12);
//tl.add(t13);
//tl.add(t14);
//tl.add(t15);
//tl.add(t16);
//tl.add(t17);
//tl.add(t18);
//tl.add(t19);
//tl.add(t20);
//
//
//t2.setPreviousTasks(tl1);
//t3.setPreviousTasks(tl2);
//t4.setPreviousTasks(tl2);
//t5.setPreviousTasks(tl3);
//t6.setPreviousTasks(tl5);
//t7.setPreviousTasks(tl4);
//t8.setPreviousTasks(tl4);
//t9.setPreviousTasks(tl4);
//t10.setPreviousTasks(tl6);
//t11.setPreviousTasks(tl7);
//
//t13.setPreviousTasks(tl8);
//t14.setPreviousTasks(tl9);
//t15.setPreviousTasks(tl10);
//t16.setPreviousTasks(tl11);
//t17.setPreviousTasks(tl12);
//t18.setPreviousTasks(tl13);
//t19.setPreviousTasks(tl13);
//t20.setPreviousTasks(tl14);
//Wbs wbs = new Wbs(tl);
//Set task = wbs.getNoPreviousTasks();
//for (Task task2 : task) {
//System.out.println("taskNumber=nb="+task2.getTaskNumber());
//}
//Set taskt = wbs.getNoNextTasks();
//for (Task task2 : taskt) {
//System.out.println("taskNumber=na="+task2.getTaskNumber());
//}
//wbs.calculateTime();
//wbs.calculateTimeArray();
//long time1 = System.currentTimeMillis();
//Task previous = new Task("1","FS",15,0);
//List tls = new LinkedList();
//tls.add(previous);
//List tl = new LinkedList();
//tl.add(previous);
//for(int i = 2;i<=2000;i++){
//Task tmp = new Task(String.valueOf(i),"FS",15,0);
//tmp.setPreviousTasks(tls);
//tls = new LinkedList();
//tls.add(tmp);
//tl.add(tmp);
//}
//long time2 = System.currentTimeMillis();
//System.out.println("构建用时："+(time2-time1));
//Wbs wbs = new Wbs(tl);
//wbs.calculateTime();
//long time3 = System.currentTimeMillis();
//System.out.println("计算用时："+(time3-time2));
//数组的计算
long time1 = System.currentTimeMillis();
int arrayLength = 200;
String[] logicarray = new String[arrayLength];
double[] delaytimearray = new double[arrayLength];
double[] durtimearray = new double[arrayLength];
Random random = new Random();
for(int i = 0; i < arrayLength;i++) {
//获得200以内的正整数为执行时间数组赋值
durtimearray[i] =Math.abs(random.nextInt())%200;
//获得20以内的整数为浮动时间赋值
delaytimearray[i] =Math.abs(random.nextInt()%20);
//获得4以内的整数为4种逻辑关系赋值
int index = Math.abs(random.nextInt())%4;
switch (index) {
case 1:
logicarray[i]="SS";
break;
case 2:
logicarray[i]="FF";
break;
case 3:
logicarray[i]="SF";
break;
default:
logicarray[i]="FS";
break;
}
}
Task previous = new Task("task1",logicarray,delaytimearray,durtimearray);
List tls = new LinkedList();
tls.add(previous);
List tl = new LinkedList();
tl.add(previous);
for(int i = 2;i<=5000;i++){
String[] logicarrayi = new String[arrayLength];
double[] delaytimearrayi = new double[arrayLength];
double[] durtimearrayi = new double[arrayLength];
Random randomi = new Random();
for(int ii = 0; ii < arrayLength;ii++) {
//获得200以内的正整数为执行时间数组赋值
durtimearrayi[ii] =Math.abs(randomi.nextInt())%200;
//获得20以内的整数为浮动时间赋值
delaytimearrayi[ii] =Math.abs(randomi.nextInt()%20);
//获得4以内的整数为4种逻辑关系赋值
int index = Math.abs(randomi.nextInt())%4;
switch (index) {
case 1:
logicarrayi[ii]="SS";
break;
case 2:
logicarrayi[ii]="FF";
break;
case 3:
logicarrayi[ii]="SF";
break;
default:
logicarrayi[ii]="FS";
break;
}
}
Task tmp = new Task("task"+i,logicarrayi,delaytimearrayi,durtimearrayi);
tmp.setPreviousTasks(tls);
tls = new LinkedList();
int previousCount = Math.abs(randomi.nextInt())%8;
for(int ii = 0; ii < previousCount;ii++) {
if(ii
tls.add(tl.get(ii));
}
}
tl.add(tmp);
}
long time2 = System.currentTimeMillis();
System.out.println("构建用时："+(time2-time1));
Wbs wbs = new Wbs(tl);
wbs.calculateTimeArray();
long time3 = System.currentTimeMillis();
System.out.println("计算用时："+(time3-time2));
}
}
分享到：
2010-06-09 14:13
浏览 4710
评论
3541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
