brute.h

Go to the documentation of this file.

// Pallas Solver
// Copyright 2015. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Author: ryan.latture@gmail.com (Ryan Latture)

#ifndef PALLAS_BRUTE_H
#define PALLAS_BRUTE_H

#include "pallas/history_concept.h"
#include "pallas/types.h"

namespace pallas {

    class Brute {
    public:
        struct Options {
            Options() {
                local_minimizer_options = GradientLocalMinimizer::Options();
                polish_output = false;
                is_silent = true;
                history_save_frequency = 0;
            };

            GradientLocalMinimizer::Options local_minimizer_options;
            
            bool polish_output;

            bool is_silent;

            unsigned int history_save_frequency;
        };

        struct Summary {
            Summary();

            std::string BriefReport() const;
            std::string FullReport() const;
            TerminationType termination_type;
            std::string message;
            double final_cost;
            GradientLocalMinimizer::Summary local_minimization_summary;
            unsigned int num_parameters;
            unsigned int num_iterations;
            double total_time_in_seconds;
            double local_minimization_time_in_seconds;
            double permutation_build_time_in_seconds;
            double cost_evaluation_time_in_seconds;
            bool was_polished;
            HistorySeries history;
        };

        struct HistoryOutput {

            HistoryOutput(unsigned int iteration_number,
                          const Vector &current_solution,
                          double best_cost,
                          const Vector &best_solution)
                    : iteration_number(iteration_number),
                      current_solution(current_solution),
                      best_cost(best_cost),
                      best_solution(best_solution) {}
            unsigned int iteration_number;
            Vector current_solution;
            double best_cost;
            Vector best_solution;
        };

        struct ParameterRange {

            ParameterRange() : start(0), stop(0), size(0) {};

            ParameterRange(double start, double stop, int size)
                    : start(start), stop(stop), size(size) {};

            double start;
            double stop;
            int size;
        };

        Brute() {};

        void Solve(const Brute::Options options,
                   const GradientProblem& problem,
                   const std::vector<Brute::ParameterRange> &parameter_ranges,
                   double* parameters,
                   Brute::Summary *global_summary);

    private:
        std::vector<Vector> expand_parameter_ranges_(const std::vector<Brute::ParameterRange> &parameter_ranges);

        std::vector<Vector> build_permutations_(const std::vector<Vector> &expanded_ranges);
    };

    void Solve(const Brute::Options options,
               const GradientProblem& problem,
               const std::vector<Brute::ParameterRange> &parameter_ranges,
               double* parameters,
               Brute::Summary *global_summary);

    void dump(const Brute::HistoryOutput &h, HistoryWriter& writer);

} // namespace pallas

#endif // PALLAS_BRUTE_H