historicalstatehandler.java

来自「用于求解TSP(Traveling salesman problem」· Java 代码 · 共 137 行

/**
 * Description: provide the capability for handling historical best state
 *
 * @ Author        Create/Modi     Note
 * Xiaofeng Xie    Jul 19, 2006
 */

package maosKernel.infoIO;

import java.io.*;
import Global.define.*;
import Global.system.io.*;
import maosKernel.represent.*;
import maosKernel.represent.space.*;
import maosKernel.represent.encode.*;

public class HistoricalStateHandler implements IDefineLowerBoundEngine {
  private boolean isOpt = false;
  private EncodedState historyState;
  private OEncodeData lowBoundEncodedData = null;
  private boolean isBrokenRecord = false;
  /**********************************************/
  private String solutionPath = "";
  /**********************************************/
  private AbsLandscape virtualLandscape;
  private AbsSolutionIOHandler solutionIOHandler;

  public HistoricalStateHandler(AbsLandscape virtualLandscape, AbsSolutionIOHandler solutionIOHandler, String solutionPath) {
    historyState = new EncodedState(virtualLandscape);
    this.solutionIOHandler = solutionIOHandler;
    this.virtualLandscape = virtualLandscape;
    this.solutionPath = solutionPath;
    isOpt = initHistoryState(historyState, virtualLandscape);
  }

  private String getOptFileContent(String problemName) throws Exception {
    String content = null;
    try {
      content = GlobalFile.getStringFromFile(solutionPath+BasicTag.FILE_SEP_TAG+problemName+".opt"+solutionIOHandler.getSolutionSuffix());
    } catch (Exception e) {
      content = GlobalFile.getStringFromFile(solutionPath+BasicTag.FILE_SEP_TAG+problemName+solutionIOHandler.getSolutionSuffix());
    }
    return content;
  }

  public void setLowerBound(OEncodeData lowBoundEncodedData) {
    this.lowBoundEncodedData = lowBoundEncodedData;
  }

  public void updateHistoricalState(EncodedState state) {
    if (isNewHistoricalState(state)) {
      historyState.importEncodeState(state);
      isBrokenRecord = true;
    }
  }

  public EncodedState getHistoricalState() {
    return historyState;
  }

  public boolean isLowerBoundState(EncodedState state) {
    return (lowBoundEncodedData!=null&&virtualLandscape.evaluate(state.getEncodeInfo(), lowBoundEncodedData));
  }

  public boolean isNewHistoricalState(EncodedState state) {
    return (!virtualLandscape.evaluate(historyState, state));
  }

  public boolean isHistoricalState(EncodedState state) {
    return (isOpt && virtualLandscape.evaluate(state, historyState)) || isLowerBoundState(state);
  }

  public boolean outputHistoryState() throws Exception {
    if (isBrokenRecord) {
      String fileName = solutionPath+BasicTag.FILE_SEP_TAG+virtualLandscape.getName();
      if (!isLowerBoundState(historyState)) {
        fileName += "."+historyState.writeEncodeInfo();
      }
      GlobalFile.saveStringToFile(solutionIOHandler.writeSolution(historyState), fileName+solutionIOHandler.getSolutionSuffix());
      isBrokenRecord = false;
      return true;
    }
    return false;
  }

  private boolean initHistoryState(EncodedState historyState, AbsLandscape virtualLandscape) {
    historyState.removeEncodeInfo();
    final String problemName = virtualLandscape.getName();
    try {
      String content = getOptFileContent(problemName);
      solutionIOHandler.readSolution(historyState, content);
      virtualLandscape.encodeRGlobalCost_AsNotEncoded(historyState);
       return true;
    } catch(Exception e) {
      File file = new File(solutionPath);
      File[] files = file.listFiles(new FilenameFilter() {
        public boolean accept(File dir, String name) {
          return(name.startsWith(problemName+".") && name.endsWith(solutionIOHandler.getSolutionSuffix()));
        }
      });
      if (files==null) return false;
      EncodedState tempState = new EncodedState(virtualLandscape);
      for (int i=0; i<files.length; i++) {
        try {
          String content = GlobalFile.getStringFromFile(files[i].getAbsolutePath());
          tempState.removeEncodeInfo();
          solutionIOHandler.readSolution(tempState, content);
          virtualLandscape.encodeRGlobalCost_AsNotEncoded(tempState);
          if (virtualLandscape.evaluate(tempState, historyState)) {
            historyState.importEncodeState(tempState);
          }
        } catch (Exception ex) {}
      }
    }
    return false;
  }

  //private known solution info
  public String printKnownSolutionInfo() {
    String msg = "@Known solution cost: ";
    if (!historyState.isEncoded()) {
      msg += "none";
    }
    else {
      msg += historyState.writeEncodeInfo();
      if (isOpt) {
        msg += "(Optimum)";
      }
    }
    if (this.lowBoundEncodedData!=null && !isOpt) {
      msg += ", lower bound is "+lowBoundEncodedData.writeInfo();
    }
    return msg;
  }
}