constr_lpball.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_FW_CONSTR_LPBALL_HPP
#define MLPACK_CORE_OPTIMIZERS_FW_CONSTR_LPBALL_HPP

#include <mlpack/prereqs.hpp>

namespace mlpack {
namespace optimization {

class ConstrLpBallSolver
{
 public:
  ConstrLpBallSolver(const double p) : p(p)
  { /* Do nothing. */ }

  ConstrLpBallSolver(const double p, const arma::vec lambda) :
      p(p), regFlag(true), lambda(lambda)
  { /* Do nothing. */ }


  void Optimize(const arma::mat& v,
                arma::mat& s)
  {
    if (p == std::numeric_limits<double>::infinity())
    {
      // l-inf ball.
      s = -sign(v);
      if (regFlag)
        s = s / lambda;   // element-wise division.
    }
    else if (p > 1.0)
    {
      // lp ball with 1<p<inf.
      if (regFlag)
        s = v / lambda;
      else
        s = v;

      double q = 1 / (1.0 - 1.0 / p);
      s = - sign(v) % pow(abs(s), q - 1);  // element-wise multiplication.
      s = arma::normalise(s, p);

      if (regFlag)
        s = s / lambda;
    }
    else if (p == 1.0)
    {
      // l1 ball, also used in OMP.
      if (regFlag)
        s = arma::abs(v / lambda);
      else
        s = arma::abs(v);

      arma::uword k = 0;
      s.max(k);  // k is the linear index of the largest element.
      s.zeros();
      s(k) = - mlpack::math::Sign(v(k));

      if (regFlag)
        s = s / lambda;
    }
    else
    {
      Log::Fatal << "Wrong norm p!" << std::endl;
    }

    return;
  }

  double P() const { return p; }
  double& P() { return p;}

  bool RegFlag() const {return regFlag;}
  bool& RegFlag() {return regFlag;}

  arma::vec Lambda() const {return lambda;}
  arma::vec& Lambda() {return lambda;}

 private:
  double p;

  bool regFlag = false;

  arma::vec lambda;
};

} // namespace optimization
} // namespace mlpack

#endif