Booth.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * Copyright (c) 2025, Davide Stocco and Enrico Bertolazzi.                  *
 *                                                                           *
 * The Optimist project is distributed under the BSD 2-Clause License.       *
 *                                                                           *
 * Davide Stocco                                           Enrico Bertolazzi *
 * University of Trento                                 University of Trento *
 * davide.stocco@unitn.it                         enrico.bertolazzi@unitn.it *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#pragma once
 
#ifndef OPTIMIST_TESTSET_BOOTH_HH
#define OPTIMIST_TESTSET_BOOTH_HH
 
#include "Optimist/Function.hh"
 
namespace Optimist {
 
  namespace TestSet {

    template <typename Vector>
      requires TypeTrait<Vector>::IsEigen && (!TypeTrait<Vector>::IsFixed ||
                                              TypeTrait<Vector>::Dimension == 2)
    class Booth : public Function<Vector, Vector, Booth<Vector>> {
     public:
      using VectorTrait = TypeTrait<Vector>;
      using Scalar      = typename Vector::Scalar;
      using typename Function<Vector, Vector, Booth<Vector>>::FirstDerivative;
      using typename Function<Vector, Vector, Booth<Vector>>::SecondDerivative;
 
      OPTIMIST_BASIC_CONSTANTS(Scalar)
 
      
      Booth() {
        this->m_solutions.resize(1);
        this->m_guesses.resize(2);
        if constexpr (VectorTrait::IsFixed) {
          this->m_solutions[0] << 1.0, 3.0;
          this->m_guesses[0] << -10, -10;
          this->m_guesses[1] << 10, 10;
        } else if constexpr (VectorTrait::IsDynamic) {
          this->m_solutions[0].resize(2);
          this->m_solutions[0] << 1.0, 3.0;
          this->m_guesses[0].resize(2);
          this->m_guesses[0] << -10, -10;
          this->m_guesses[1].resize(2);
          this->m_guesses[1] << 10, 10;
        } else if constexpr (VectorTrait::IsSparse) {
          this->m_solutions[0].resize(2);
          this->m_solutions[0].reserve(2);
          this->m_solutions[0].coeffRef(0) = 1.0;
          this->m_solutions[0].coeffRef(1) = 3.0;
          this->m_guesses[0].resize(2);
          this->m_guesses[0].reserve(2);
          this->m_guesses[0].coeffRef(0) = -10;
          this->m_guesses[0].coeffRef(1) = -10;
          this->m_guesses[1].resize(2);
          this->m_guesses[1].reserve(2);
          this->m_guesses[1].coeffRef(0) = 10;
          this->m_guesses[1].coeffRef(1) = 10;
        }
      }

      constexpr std::string name_impl() const {
        return "Booth";
      }

      bool evaluate_impl(const Vector &x, Vector &out) const {
#define CMD "Optimist::TestSet::Booth::evaluate_impl(...): "
 
        if constexpr (VectorTrait::IsFixed) {
          out << x(0) + 2.0 * x(1) - 7.0, 2.0 * x(0) + x(1) - 5.0;
          return out.allFinite();
        } else if constexpr (VectorTrait::IsDynamic) {
          out.resize(2);
          out << x(0) + 2.0 * x(1) - 7.0, 2.0 * x(0) + x(1) - 5.0;
          return out.allFinite();
        } else if constexpr (VectorTrait::IsSparse) {
          out.resize(2);
          out.reserve(2);
          out.coeffRef(0) = x.coeff(0) + 2.0 * x.coeff(1) - 7.0;
          out.coeffRef(1) = 2.0 * x.coeff(0) + x.coeff(1) - 5.0;
          for (typename Vector::InnerIterator it(out); it; ++it) {
            if (!std::isfinite(it.value())) {
              return false;
            }
          }
          return true;
        } else {
          OPTIMIST_ERROR(CMD "input type not supported.");
          return false;
        }
 
#undef CMD
      }

      bool first_derivative_impl(const Vector & /*x*/,
                                 FirstDerivative &out) const {
#define CMD "Optimist::TestSet::Booth::first_derivative_impl(...): "
 
        if constexpr (VectorTrait::IsFixed) {
          out << 1.0, 2.0, 2.0, 1.0;
        } else if constexpr (VectorTrait::IsDynamic) {
          out.resize(2, 2);
          out << 1.0, 2.0, 2.0, 1.0;
        } else if constexpr (VectorTrait::IsSparse) {
          out.resize(2, 2);
          out.reserve(4);
          std::vector<Eigen::Triplet<Scalar>> triplets;
          triplets.reserve(4);
          triplets.emplace_back(0, 0, 1.0);
          triplets.emplace_back(0, 1, 2.0);
          triplets.emplace_back(1, 0, 2.0);
          triplets.emplace_back(1, 1, 1.0);
          out.setFromTriplets(triplets.begin(), triplets.end());
        } else {
          OPTIMIST_ERROR(CMD "input type not supported.");
          return false;
        }
        return true;
 
#undef CMD
      }

      bool second_derivative_impl(const Vector & /*x*/,
                                  SecondDerivative &out) const {
#define CMD "Optimist::TestSet::Booth::second_derivative_impl(...): "
 
        out.resize(2);
        std::for_each(out.begin(), out.end(), [](auto &m) {
          if constexpr (VectorTrait::IsFixed) {
            m.setZero();
          }
          if constexpr (VectorTrait::IsDynamic) {
            m.resize(2, 2);
            m.setZero();
          }
          if constexpr (VectorTrait::IsSparse) {
            m.resize(2, 2);
            m.reserve(4);
            std::vector<Eigen::Triplet<Scalar>> triplets;
            triplets.reserve(4);
            triplets.emplace_back(0, 0, 0.0);
            triplets.emplace_back(0, 1, 0.0);
            triplets.emplace_back(1, 0, 0.0);
            triplets.emplace_back(1, 1, 0.0);
            m.setFromTriplets(triplets.begin(), triplets.end());
          } else {
            OPTIMIST_ERROR(CMD "input type not supported.");
          }
        });
        return true;
 
#undef CMD
      }
 
    };  // class Booth
 
  }  // namespace TestSet
 
}  // namespace Optimist
 
#endif  // OPTIMIST_TESTSET_BOOTH_HH