Java SolverFactory类代码示例

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
@Override
public void applyCustomProperties(Map<String, String> customPropertyMap) {
    String partitionSolverConfigResource = customPropertyMap.get(PARTITION_SOLVER_CONFIG_RESOURCE_PROPERTY);
    if (partitionSolverConfigResource == null) {
        throw new IllegalArgumentException("A customProperty (" + PARTITION_SOLVER_CONFIG_RESOURCE_PROPERTY
                + ") is missing from the solver configuration.");
    }
    String partitionCountString = customPropertyMap.get(PARTITION_COUNT_PROPERTY);
    if (partitionCountString == null) {
        throw new IllegalArgumentException("A customProperty (" + PARTITION_COUNT_PROPERTY
                + ") is missing from the solver configuration.");
    }
    try {
        partitionCount = Integer.parseInt(partitionCountString);
    } catch (NumberFormatException e) {
        throw new IllegalArgumentException("The customProperty (" + PARTITION_COUNT_PROPERTY
                + ")'s value (" + partitionCount + ") is not a valid int.", e);
    }
    if (customPropertyMap.size() != 2) {
        throw new IllegalArgumentException("The customPropertyMap's size (" + customPropertyMap.size()
                + ") is not 1.");
    }
    solverFactory = SolverFactory.createFromXmlResource(partitionSolverConfigResource);
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
/**
 * Return new or cached score only solver. Detect changes to the rule list
 * and re-create the solver in that case.
 *
 * @param customDrlFiles the list of user provided DRL files
 * @return score only solver
 */
public static Solver getScoreOnlySolver(List<Path> customDrlFiles) {
    Set<Path> changeDetector = new HashSet<>(customDrlFiles);
    changeDetector.retainAll(recordedCustomDrlFiles);

    if (scoreOnlySolver != null
            && customDrlFiles.size() == changeDetector.size()
            && recordedCustomDrlFiles.size() == changeDetector.size()) {
        return scoreOnlySolver;
    }

    SolverFactory solverFactory =
            SolverFactory.createFromXmlResource("org/ovirt/optimizer/solver/rules/scoreonly.xml");
    addCustomDrlFiles(solverFactory.getSolverConfig().getScoreDirectorFactoryConfig(), customDrlFiles);
    scoreOnlySolver = solverFactory.buildSolver();
    recordedCustomDrlFiles = customDrlFiles;
    return scoreOnlySolver;
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    DevoxxImporter devoxxImporter = new DevoxxImporter();
    SolverFactory<Conference> solverFactory = SolverFactory.createFromXmlResource(
            OptaConfPlanner.SOLVER_CONFIG);

    Conference conference = devoxxImporter.importConference(false);
    logger.info("Imported.");

    Solver<Conference> solver = solverFactory.buildSolver();
    conference = solver.solve(conference);
    logger.info("Solved.");

    ConferenceFileIO fileIO = new ConferenceFileIO();
    File outputFile = File.createTempFile("devoxx2016-", "." + fileIO.getOutputFileExtension());
    fileIO.write(conference, outputFile);
    logger.info("Written.");
    Desktop.getDesktop().open(outputFile);
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
public static void main(String[] args) {
    String filename = "roster-10spots-28days";
    WorkerRosteringSolutionFileIO solutionFileIO = new WorkerRosteringSolutionFileIO();
    Roster roster = solutionFileIO.read(new File("data/workerrostering/import/" + filename + ".xlsx"));
    // WorkerRosteringGenerator generator = new WorkerRosteringGenerator();
    // Roster roster = generator.generateRoster(10, 28);

    // LAB-SOLUTION-START
    SolverFactory<Roster> solverFactory = SolverFactory.createFromXmlResource(
            "org/optaplanner/training/workerrostering/solver/workerRosteringSolverConfig.xml");
    roster = solverFactory.buildSolver().solve(roster);
    // LAB-SOLUTION-END

    File outputSolutionFile = new File("data/workerrostering/export/" + filename + "-solved"
            + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss", Locale.ENGLISH)) + ".xlsx");
    solutionFileIO.write(roster, outputSolutionFile);
    Desktop desktop = Desktop.getDesktop();
    if (desktop.isSupported(Desktop.Action.OPEN)) {
        try {
            desktop.open(outputSolutionFile);
        } catch (IOException e) {
            throw new IllegalArgumentException("Could not open outputSolutionFile (" + outputSolutionFile
                    + ") on this operation system.", e);
        }
    }
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
public List<ShiftAssignment> plan() {
    SolverFactory<Solution> solverFactory = SolverFactory.createFromXmlResource("planner/EmployeeRosteringSolverConfig.xml");
    Solver solver = solverFactory.buildSolver();

    EmployeeRoster employeeRoster = new EmployeeRoster();
    employeeRoster.setCode("TEST");
    employeeRoster.setSkillList(employeeRepository.listSkills());
    employeeRoster.setShiftTypeList(shiftRepository.listShiftTypes());
    employeeRoster.setShiftTypeSkillRequirementList(generateShiftTypeSkillRequirements());
    employeeRoster.setPatternList(patternsRepository.listAll());
    employeeRoster.setContractList(contractRepository.listAll());
    employeeRoster.setContractLineList(generateContractLines());
    employeeRoster.setPatternContractLineList(generateContractPatternList());
    employeeRoster.setEmployeeList(employeeRepository.listAll());
    employeeRoster.setSkillProficiencyList(generateSkillProficiency());
    employeeRoster.setShiftDateList(shiftRepository.listShiftDates());
    employeeRoster.setShiftList(shiftRepository.listShifts());
    employeeRoster.setDayOffRequestList(employeeRepository.listDayOffRequests());
    employeeRoster.setDayOnRequestList(employeeRepository.listDayOnRequests());
    employeeRoster.setShiftOffRequestList(employeeRepository.listShiftOffRequests());
    employeeRoster.setShiftOnRequestList(employeeRepository.listShiftOnRequests());
    employeeRoster.setEmployeeRosterParametrization(generateEmployeeRosterInfo());
    employeeRoster.setShiftAssignmentList(generateAssigments());

    employeeRoster = (EmployeeRoster) solver.solve(employeeRoster);
    final HardSoftScore score = employeeRoster.getScore();
    for (ShiftAssignment shiftAssignment : employeeRoster.getShiftAssignmentList()) {
        shiftRepository.createShiftAssignment(shiftAssignment.getShift(), shiftAssignment.getEmployee());
    }
    messageService.informUser(String.format("'%s' score ", score.toString()));

    return shiftRepository.listShiftAssignments();
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
public static void main(String[] args) {
    List<Roster> rosterList = generateRosters();

    SolverFactory<Roster> solverFactory = SolverFactory.createFromXmlResource(
            "org/optaplanner/openshift/employeerostering/server/solver/employeeRosteringSolverConfig.xml");
    PlannerBenchmarkFactory benchmarkFactory = PlannerBenchmarkFactory.createFromSolverFactory(solverFactory);
    PlannerBenchmark plannerBenchmark = benchmarkFactory.buildPlannerBenchmark(rosterList);
    plannerBenchmark.benchmark();
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
@Override
public Boolean call() throws Exception {
    ObjectMapper mapper = ObjectMapperFactory.getInstance();
    ConferenceData data;
    data = mapper.readValue(yml, ConferenceData.class);
    data.setRoomCapacityFactor(capacityFactor);
    SolverFactory<ConferenceData> solverFactory = SolverFactory.createFromXmlResource(SOLVER_CONFIG);
    solverFactory.getSolverConfig().getTerminationConfig().setSecondsSpentLimit((long) duration);
    solver = solverFactory.buildSolver();
    solver.solve(data);
    System.out.println("solver.getBestScore() = " + solver.getBestScore());
    return true;
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public ProblemSolution solveProblem(ProblemDescription problemDescription) {
    logger.info("Received request to route: " + problemDescription);
    SolverFactory solverFactory = SolverFactory.createFromXmlResource(SOLVER_CONFIG);
    Solver solver = solverFactory.buildSolver();
    RoutingSolution routingSolution = problemDescription.createEmptyRoutingSolution();
    solver.solve(routingSolution);
    return ProblemSolution.create((RoutingSolution) solver.getBestSolution());
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
@Override
public void run() {
    SolverFactory sF = SolverFactory.createFromXmlResource("solver/tabuSearch_solverConfig.xml");
    Solver solver = sF.buildSolver();
    AlocacaoHorario bestSolution;

    solver.addEventListener(event -> {
        if (event.isEveryProblemFactChangeProcessed()) {
            AlocacaoHorario newBestSolution;
            System.out.println("Encontrou nova solução.");

            newBestSolution = (AlocacaoHorario) event.getNewBestSolution();

            logarSolucao(newBestSolution);

            listenner.update(Resolvedor.this, event.getNewBestSolution());
        }
    });

    solver.solve(alocacaoHorario);

    bestSolution = (AlocacaoHorario) solver.getBestSolution();

    logarSolucao(bestSolution);

    listenner.update(this, bestSolution);
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
private void split(int partitionCount,String sliceOrChunk) {
    File inputFile = new File(importer.getInputDir(), "gifts.csv");
    ReindeerRoutingSolution originalSolution = (ReindeerRoutingSolution) importer.readSolution(inputFile);
    ScoreDirector scoreDirector = SolverFactory.createFromXmlResource(ReindeerRoutingApp.SOLVER_CONFIG)
            .buildSolver().getScoreDirectorFactory().buildScoreDirector();

    ReindeerRoutingSolution cloneSolution = (ReindeerRoutingSolution) ((InnerScoreDirector) scoreDirector).cloneSolution(originalSolution);
    WeightFactorySelectionSorter<ReindeerRoutingSolution, GiftAssignment> sorter = new WeightFactorySelectionSorter<ReindeerRoutingSolution, GiftAssignment>(
            new NorthPoleAngleGiftAssignmentDifficultyWeightFactory(), SelectionSorterOrder.ASCENDING);
    sorter.sort(cloneSolution, cloneSolution.getGiftAssignmentList());

    int giftSize = cloneSolution.getGiftList().size();
    for (int i = 0; i < partitionCount; i++) {
        ReindeerRoutingSolution partitionSolution = new ReindeerRoutingSolution();
        partitionSolution.setId(cloneSolution.getId());
        int giftSubSize = giftSize / partitionCount;
        List<GiftAssignment> partitionGiftAssignmentList = cloneSolution.getGiftAssignmentList().subList(giftSubSize * i, giftSubSize * (i + 1));
        List<Gift> partitionGiftList = new ArrayList<Gift>(giftSubSize);
        for (GiftAssignment partitionGiftAssignment : partitionGiftAssignmentList) {
            partitionGiftList.add(partitionGiftAssignment.getGift());
        }
        partitionSolution.setGiftList(partitionGiftList);
        int reindeerSubSize = cloneSolution.getReindeerList().size() / partitionCount;
        partitionSolution.setReindeerList(cloneSolution.getReindeerList().subList(reindeerSubSize * i, reindeerSubSize * (i + 1)));
        partitionSolution.setGiftAssignmentList(partitionGiftAssignmentList);
        File outputFile = new File (importer.getInputDir(), sliceOrChunk + "s/gifts_" + sliceOrChunk + i + ".csv");
        writeSolutionButGiftsOnly(partitionSolution, outputFile);
    }
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    System.setProperty("logback.level.org.optaplanner", "info"); // don't waste time logging too much

    // Build the Solver
    // TODO cli arg
    SolverFactory<ReindeerRoutingSolution> solverFactory = SolverFactory.createFromXmlResource(SOLVER_CONFIG);
    final Solver<ReindeerRoutingSolution> solver = solverFactory.buildSolver();

    // Load the problem
    final ReindeerRoutingSolution unsolvedReindeerRoutingSolution = (ReindeerRoutingSolution) (new ReindeerRoutingImporter().readSolution(new File("data/sss/import/gifts.csv")));

    // Solve the problem in the background
    System.out.println("OptaPlanner is working hard on your problem. Press any key to stop.");
    Runnable solving = new Runnable() {
        @Override
        public void run() {
            solver.solve(unsolvedReindeerRoutingSolution);
        }
    };
    E.submit(solving);

    // wait for the user to terminate
    System.in.read();
    System.out.println("OptaPlanner will now terminate.");

    // terminate on keypress and write the solution
    new ReindeerRoutingExporter().writeSolution(solver.getBestSolution(), new File("data/sss/solved/solution.csv")); // TODO cli arg
    System.out.println("Solution safely stored.");
    solver.terminateEarly();
    E.shutdownNow();
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
public SolverFactory getSolverFactory() {
    // The solver is built from an XML that contains a basic configuration.
    // This should be a bit simpler than building the solver from scratch.
    SolverFactory solverFactory = new XmlSolverFactory(BASE_SOLVER_XML_PATH);
    configureSolver(solverFactory.getSolverConfig(), vmPlacementConfig);
    return solverFactory;
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected VehicleRoutingSolution doInBackground(VehicleRoutingSolution... vrs) {
    Log.d(TAG, "Building solver.");

    // creates solver
    try {
        InputStream is = fragment.getActivity().getAssets().open("solvers/" + algorithm);
        SolverFactory solverFactory = SolverFactory.createFromXmlInputStream(is);
        solverFactory.getSolverConfig().getTerminationConfig().setSecondsSpentLimit(timeLimit);
        solver = solverFactory.buildSolver();
    } catch (IOException e) {
        e.printStackTrace();
    }

    // adds solver listener for new best solution
    solver.addEventListener(new SolverEventListener() {
        @Override
        public void bestSolutionChanged(BestSolutionChangedEvent event) {
            if (running) {
                publishProgress((VehicleRoutingSolution) event.getNewBestSolution());
            }
        }
    });

    // starts solver
    Log.d(TAG, "Solver built, running solver.");
    solver.solve(vrs[0]);

    // end of calculation
    running = false;
    return (VehicleRoutingSolution) solver.getBestSolution();
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
Builder interpretXml() {
  if (isBenchmark()) {
    configs = getConfigsFromBenchmark(verifyNotNull(getSolverXml()));
  } else {
    final SolverFactory factory =
      SolverFactory.createFromXmlReader(new StringReader(getSolverXml()));
    configs = ImmutableMap.<String, SolverConfig>builder()
      .put(SINGLE_SOLVER_KEY, factory.getSolverConfig())
      .build();
  }
  if (getSolverKey() != null) {
    checkArgument(verifyNotNull(configs).containsKey(getSolverKey()));
  }
  return this;
}
 

import org.optaplanner.core.api.solver.SolverFactory; //导入依赖的package包/类
public static void main(String[] args) {
    Election election = readElection();

    // LAB-SOLUTION-START
    SolverFactory<Election> solverFactory = SolverFactory.createFromXmlResource(
            "org/optaplanner/training/election/solver/electionSolverConfig.xml");
    election = solverFactory.buildSolver().solve(election);
    // LAB-SOLUTION-END

    printElection(election);
}