problem_scaling.hpp

// Copyright (c) Sleipnir contributors
 
#pragma once
 
#include <algorithm>
#include <utility>
 
#include <Eigen/Core>
#include <Eigen/SparseCore>
 
#include "sleipnir/optimization/solver/util/sparse_inf_norms.hpp"
 
// See docs/algorithms.md#Works_cited for citation definitions
 
namespace slp {
 
template <typename Scalar>
struct ProblemScaling {
  using DenseVector = Eigen::Vector<Scalar, Eigen::Dynamic>;
  using SparseMatrix = Eigen::SparseMatrix<Scalar>;
  using SparseVector = Eigen::SparseVector<Scalar>;
 
  Scalar f = Scalar(1);
 
  DenseVector c_e;
 
  DenseVector c_i;
 
  ProblemScaling() = default;
 
  ProblemScaling(Scalar f, DenseVector c_e, DenseVector c_i)
      : f{f}, c_e{std::move(c_e)}, c_i{std::move(c_i)} {}
 
  explicit ProblemScaling(const DenseVector& g) {
    constexpr Scalar g_max(100);
 
    f = std::min(Scalar(1), g_max / g.template lpNorm<Eigen::Infinity>());
  }
 
  ProblemScaling(const DenseVector& g, const SparseMatrix& A_e) {
    constexpr Scalar g_max(100);
 
    f = std::min(Scalar(1), g_max / g.template lpNorm<Eigen::Infinity>());
    c_e = (g_max / sparse_inf_norms(A_e).array()).min(Scalar(1)).matrix();
  }
 
  ProblemScaling(const DenseVector& g, const SparseMatrix& A_e,
                 const SparseMatrix& A_i) {
    constexpr Scalar g_max(100);
 
    f = std::min(Scalar(1), g_max / g.template lpNorm<Eigen::Infinity>());
    c_e = (g_max / sparse_inf_norms(A_e).array()).min(Scalar(1)).matrix();
    c_i = (g_max / sparse_inf_norms(A_i).array()).min(Scalar(1)).matrix();
  }
 
  bool is_identity() const {
    return f == Scalar(1) && c_e.size() == 0 && c_i.size() == 0;
  }
};
 
}  // namespace slp