KktSolver.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright (C) 2014-2018 Allan Leal
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library. If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// C++ includes
#include <memory>
 
// Reaktoro includes
#include <Reaktoro/Math/Matrix.hpp>
#include <Reaktoro/Optimization/Hessian.hpp>
 
namespace Reaktoro {
 
struct KktResult
{
    bool succeeded = false;
 
    double time_decompose = 0;
 
    double time_solve = 0;
};
 
enum class KktMethod
{
    PartialPivLU,
 
    FullPivLU,
 
    Nullspace,
 
    Rangespace,
 
    Automatic,
};
 
struct KktOptions
{
    KktMethod method = KktMethod::Automatic;
};
 
struct KktMatrix
{
    KktMatrix(const Hessian& H, MatrixConstRef A, VectorConstRef x, VectorConstRef z)
    : H(H), A(A), x(x), z(z)
    {}
 
    KktMatrix(const Hessian& H, MatrixConstRef A, VectorConstRef x, VectorConstRef z, double gamma, double delta)
    : H(H), A(A), x(x), z(z), gamma(gamma), delta(delta)
    {}
 
    const Hessian& H;
 
    MatrixConstRef A;
 
    VectorConstRef x;
 
    VectorConstRef z;
 
    const double gamma = 0.0;
 
    const double delta = 0.0;
};
 
struct KktSolution
{
    Vector dx;
 
    Vector dy;
 
    Vector dz;
};
 
struct KktVector
{
    Vector rx;
 
    Vector ry;
 
    Vector rz;
};
 
class KktSolver
{
public:
    KktSolver();
 
    KktSolver(const KktSolver& other);
 
    virtual ~KktSolver();
 
    auto operator=(KktSolver other) -> KktSolver&;
 
    auto result() const -> const KktResult&;
 
    auto setOptions(const KktOptions& options) -> void;
 
    auto decompose(const KktMatrix& lhs) -> void;
 
    auto solve(const KktVector& rhs, KktSolution& sol) -> void;
 
private:
    struct Impl;
 
    std::unique_ptr<Impl> pimpl;
};
 
} // namespace Reaktoro