.. _program_listing_file_include_solvers_PathSolver.h:

Program Listing for File PathSolver.h
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_solvers_PathSolver.h>` (``include/solvers/PathSolver.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /* #############################################
    *             This file is part of
    *                    ZERO
    *
    *             Copyright (c) 2020
    *     Released under the Creative Commons
    *         CC BY-NC-SA 4.0 License
    *
    *              Find out more at
    *        https://github.com/ds4dm/ZERO
    * #############################################*/
   
   
   #pragma once
   #include "zero.h"
   #include <armadillo>
   extern "C" {
   #include <MCP_Interface.h>
   #include <Output_Interface.h>
   #include <Presolve_Interface.h>
   }
   namespace Solvers {
   
   
     class PATH {
   
     private:
        typedef struct {
           int n;   
           int nnz; 
   
           double *x;  
           double *lb; 
           double *ub; 
   
           int *   m_start; 
           int *   m_len; 
           int *   m_row; 
           double *m_data; 
   
           double *q; 
        } PATHProblem;
   
   
        ZEROStatus    status = ZEROStatus::Numerical; 
        bool          Filled; 
        PATHProblem   Problem;
        MCP_Interface PATH_Interface = {
             this,
             reinterpret_cast<void (*)(void *, int *, int *)>(this->problem_size),
             reinterpret_cast<void (*)(void *, int, double *, double *, double *)>(this->bounds),
             reinterpret_cast<int (*)(void *, int, double *, double *)>(&this->function_evaluation),
             reinterpret_cast<int (*)(
                   void *, int, double *, int, double *, int *, int *, int *, int *, double *)>(
                   &this->jacobian_evaluation),
             static_cast<void (*)(void *)>(this->start),
             NULL,
             NULL,
             NULL,
             NULL}; 
        Presolve_Interface PATH_Presolve = {
             NULL,
             NULL,
             NULL,
             NULL,
             NULL,
             reinterpret_cast<void (*)(void *, int, int *)>(this->mcp_typ),
             NULL}; 
   
        Output_Interface PATH_Output = {
             NULL,
             reinterpret_cast<void (*)(void *, int, char *)>(this->messageCB),
             NULL}; 
   
        int  CreateLMCP(int    n,
                             int    m_nnz,
                             int    m_i[],
                             int    m_j[],
                             double m_ij[],
                             double q[],
                             double lb[],
                             double ub[],
                             double x[],
                             double z[],
                             int    verbose,
                             double timeLimit);
        void sort(int rows, int cols, int elements, int *row, int *col, double *data);
        void C_problem_size(int *n, int *nnz);
        void C_bounds(int n, double *z, double *lb, double *ub);
        int  C_function_evaluation(int n, double *x, double *f);
        int  C_jacobian_evaluation(int     n,
                                            double *x,
                                            int     wantf,
                                            double *f,
                                            int *   nnz,
                                            int *   col_start,
                                            int *   col_len,
                                            int *   row,
                                            double *data);
   
     public:
        PATH() = delete;
        PATH(const arma::sp_mat &  M,
               const arma::vec &     q,
               const perps &         Compl,
               const VariableBounds &Bounds,
               arma::vec &           z,
               arma::vec  &           x,
               double                timeLimit,
               bool verbose);
        ZEROStatus getStatus() const { return this->status; } 
   
   
        static void *messageCB(void *dat, int mode, char *buf);
        static void *mcp_typ(void *dat, int nnz, int *typ);
   
   
   
        static int jacobian_evaluation(void *  dat,
                                                 int     n,
                                                 double *x,
                                                 int     wantf,
                                                 double *f,
                                                 int *   nnz,
                                                 int *   col_start,
                                                 int *   col_len,
                                                 int *   row,
                                                 double *data);
   
   
   
        static int function_evaluation(void *dat, int n, double *x, double *f);
   
   
        static void start(void *dat);
   
        static void bounds(void *dat, int n, double *x, double *lb, double *ub);
   
        static void problem_size(void *dat, int *n, int *nnz);
     };
   } // namespace Solvers