sampling.h

Go to the documentation of this file.

// Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Author: Stefan Vigerske

#ifndef SAMPLING_H
#define SAMPLING_H

#include "standard.h"
#include "problem.h"
#include "func.h"
#include "opt.h"

class Sampling {
        friend ostream& operator<<(ostream& out, const Sampling& s) {
                s.print(out);
                return out;
        }

        protected:
                int montecarlo;
                int vertices;
                bool midpoint;
                bool bounds;

        public:
                Sampling(Pointer<Param> param=NULL, char* param_prefix=NULL);
                
                virtual ~Sampling() { }
                
                virtual int get_points(vector<dvector>& sample_set, const UserVector<double>& lower, const UserVector<double>& upper);
                
                void get_points(vector<vector<dvector> >& sample_set, const UserVector<double>& lower, const UserVector<double>& upper, const vector<ivector>& block) {
                        assert(sample_set.size()==block.size());
                        for (int k=0; k<block.size(); k++) get_points(sample_set[k], lower(block[k]), upper(block[k]));
                }

                Pointer<vector<vector<dvector> > > get_points(const UserVector<double>& lower, const UserVector<double>& upper, const vector<ivector>& block) {
                        Pointer<vector<vector<dvector> > > ss(new vector<vector<dvector> >(block.size()));
                        get_points(*ss, lower, upper, block);
                        return ss;
                }

                virtual void print(ostream& out) const {
                        out << "Montecarlo points: " << montecarlo << endl
                            << "Vertices points  : " << vertices << endl
                            << "Midpoint         : " << (midpoint ? "yes" : "no") << endl
                          << "Bounds           : " << (bounds ? "yes" : "no") << endl
                        ;
                }

};

class Sampling_Vertices {
        public:
                int vertices;

                Sampling_Vertices(Pointer<Param> param=NULL, char* param_prefix=NULL);

                void get_points(vector<vector<dvector> >& sample_set, const UserVector<double>& lower, const UserVector<double>& upper, const vector<ivector>& block, const vector<Pointer<set<int> > >& i_quad, const vector<Pointer<set<int> > > &i_nonquadlin);

                void get_points(vector<vector<dvector> >& sample_set, const UserVector<double>& lower, const UserVector<double>& upper, const SepQcFunc& f);

                int get_points(vector<dvector>& sample_set, const UserVector<double>& lower, const UserVector<double>& upper, set<int>& i_quad, set<int>& i_nonquadlin);

                int get_points(vector<dvector>& sample_set, const UserVector<double>& lower, const UserVector<double>& upper, const SparsityInfo& si);

                int get_points(vector<dvector>& sample_set, const UserVector<double>& lower, const UserVector<double>& upper);
};

class SimpleEquationSolver : public Solver {
        private:
                const Func& f;
                const UserVector<double>& lower;
                const UserVector<double>& upper;

                int bisection_iter_max;

                int run(const dvector& start, double val, dvector& dir);

        public:
                SimpleEquationSolver(const Func& f_, const UserVector<double>& lower_, const UserVector<double>& upper_, Pointer<Param> param=NULL)
                : Solver(f_.dim()), f(f_), lower(lower_), upper(upper_)
                { iter_max=param ? param->get_i("SimpleEquationSolver max iter", 4) : 4;
                  tol=param ? param->get_d("SimpleEquationSolver tolerance", 1e-4) : 1e-4;
                        bisection_iter_max=param ? param->get_i("SimpleEquationSolver bisection max iter", 1000) : 1000;
                }

                int solve(dvector& start);

                int solve() {
                        dvector start(lower); start+=upper; start*=.5;
                        return solve(start);
                }


};

class Sampling_check {
        private:
                Pointer<Param> param;

        public:
                Sampling_check(Pointer<Param> param_)
                : param(param_)
                { }

                void check(vector<vector<dvector> >& sample_set, const SepQcFunc& f, bool eq, const vector<Pointer<set<int> > >& i_lin, const UserVector<double>& lower, const UserVector<double>& upper, const vector<int>& start, int min_keep=0);

                void check(vector<vector<dvector> >& sample_set, const SepQcFunc& f, bool eq, const UserVector<double>& lower, const UserVector<double>& upper, const vector<int>& start, int min_keep);
};

class Sampling_Minimizer {
        private:
                bool minimizer;
                Pointer<Param> param;

        public:
                Sampling_Minimizer(Pointer<Param> param_=NULL, char* param_prefix=NULL);

                bool add_minimizer(vector<vector<dvector> >& sample_set, Pointer<SepQcFunc> f, const UserVector<double>& lower, const UserVector<double>& upper);

                bool add_minimizer(vector<dvector>& sample_set, Pointer<Func> f, const UserVector<double>& lower, const UserVector<double>& upper, dvector& start);
};

#endif

---