historicalstatehandler.java

pso源程序

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

package maosKernel.infoIO.historical;

import java.io.*;
import Global.system.*;
import Global.system.io.*;
import maosKernel.represent.*;
import maosKernel.represent.landscape.*;
import maosKernel.memory.*;
import maosKernel.represent.encode.*;
import maosKernel.infoIO.*;
import maosKernel.infoIO.setting.*;
//import implement.GCP.behavior.mutate.*;

public class HistoricalStateHandler implements IDefineLowerBoundEngine, IHistoricalHandleEngine {
  private boolean isOpt = false;
  private EncodedState historyState;
  private OEncodeData lowBoundEncodedData = null;
  private boolean isBrokenRecord = false;
  /**********************************************/
  private ISolutionIOEngine solutionIOEngine;
  /**********************************************/
  private AbsLandscape virtualLandscape;
  private AbsSolutionIOHandler solutionIOHandler;

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

  private String getOptFile(String problemName) throws Exception {
    return solutionIOEngine.getOptimalSolutionFileName(virtualLandscape.getKey(), problemName, false);
  }

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

  public boolean updateHistoricalState(EncodedState state) {
    if (isNewHistoricalState(state)) {
      historyState.importEncodeState(state);
      isBrokenRecord = true;
      this.isOpt = false;
      return true;
    }
    return false;
  }

  public EncodedState getHistoricalState() {
    return historyState;
  }

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

  public boolean isFullHistoricalState(EncodedState state) {
    return isOptimalState(state)||isNewHistoricalState(state);
  }

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

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

  public boolean outputHistoryState() throws Exception {
    if (isBrokenRecord) {
      String fileName;
      String instanceName = virtualLandscape.getName();
      String problemType = virtualLandscape.getKey();
      if (!isLowerBoundState(historyState)) {
        fileName = solutionIOEngine.getNormalSolutionFileName(problemType, instanceName, historyState.writeEncodeInfo());
      } else {
        fileName = solutionIOEngine.getOptimalSolutionFileName(problemType, instanceName, true);
      }
      try {
        GlobalFile.saveStringToFile(solutionIOHandler.writeSolution(historyState), fileName);
        GradedOut.showNORMALMessage("@ Output new record solution to file: "+ fileName);
      } catch (Exception e) {
        GradedOut.showNORMALMessage(e.getMessage());
      }
      isBrokenRecord = false;
      return true;
    }
    return false;
  }

  private boolean initHistoryState(EncodedState historyState, AbsLandscape virtualLandscape) {
    historyState.removeEncodeInfo();
    final String problemName = virtualLandscape.getName();
    String fileName = null, content;
    boolean isOpt = false;
    try {
      fileName = getOptFile(problemName);
      content = GlobalFile.getStringFromFile(fileName);
      solutionIOHandler.readSolution(historyState, content);
      EncodedStateHandler.encodeGlobalCost_AsNotEncoded(virtualLandscape, historyState);
//      RandomStableCSP1Mover mVDMutator = new RandomStableCSP1Mover();
//      mVDMutator.setInfo(virtualLandscape);
//      mVDMutator.setState(historyState.getSearchState());
//      mVDMutator.outputZeroNumber();

      isOpt = true;
    } catch(Exception e) {
      File file = new File(solutionIOEngine.getSolutionPath(virtualLandscape.getKey()));
      File[] files = file.listFiles(solutionIOEngine.getSolutionFilter(problemName));
      if (files==null) return false;
      EncodedState tempState = new EncodedState(virtualLandscape);
      for (int i=0; i<files.length; i++) {
        try {
          content = GlobalFile.getStringFromFile(files[i].getAbsolutePath());
          tempState.removeEncodeInfo();
          solutionIOHandler.readSolution(tempState, content);
          EncodedStateHandler.encodeGlobalCost_AsNotEncoded(virtualLandscape, tempState);
          if (EncodedStateHandler.evaluate(virtualLandscape, tempState, historyState)) {
            historyState.importEncodeState(tempState);
            fileName = files[i].getAbsolutePath();
          }
        } catch (Exception ex) {}
      }
    }
    SystemSettingPath.submitUsedFile("Historical_Solution", fileName);
    return isOpt;
  }

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