highs-sys 1.14.2

Rust binding for the HiGHS linear programming solver. See http://highs.dev.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

/*
 * basiclu_get_factors.c
 *
 * Copyright (C) 2016-2018  ERGO-Code
 *
 */

#include "ipm/basiclu/lu_internal.h"

lu_int basiclu_get_factors
(
    lu_int istore[],
    double xstore[],
    lu_int Li[],
    double Lx[],
    lu_int Ui[],
    double Ux[],
    lu_int Wi[],
    double Wx[],
    lu_int rowperm[],
    lu_int colperm[],
    lu_int Lcolptr[],
    lu_int Lrowidx[],
    double Lvalue_[],
    lu_int Ucolptr[],
    lu_int Urowidx[],
    double Uvalue_[]
)
{
    struct lu this;
    lu_int m, status;

    status = lu_load(&this, istore, xstore, Li, Lx, Ui, Ux, Wi, Wx);
    if (status != BASICLU_OK)
        return status;
    if (this.nupdate != 0)
    {
        status = BASICLU_ERROR_invalid_call;
        return lu_save(&this, istore, xstore, status);
    }
    m = this.m;

    if (rowperm)
        memcpy(rowperm, this.pivotrow, m*sizeof(lu_int));
    if (colperm)
        memcpy(colperm, this.pivotcol, m*sizeof(lu_int));

    if (Lcolptr && Lrowidx && Lvalue_)
    {
        const lu_int *Lbegin_p  = this.Lbegin_p;
        const lu_int *Ltbegin_p = this.Ltbegin_p;
        const lu_int *Lindex    = this.Lindex;
        const double *Lvalue    = this.Lvalue;
        const lu_int *p         = this.p;
        lu_int *colptr          = this.iwork1; /* size m workspace */
        lu_int i, k, put, pos;

        /*
         * L[:,k] will hold the elimination factors from the k-th pivot step.
         * First set the column pointers and store the unit diagonal elements
         * at the front of each column. Then scatter each row of L' into the
         * columnwise L so that the row indices become sorted.
         */
        put = 0;
        for (k = 0; k < m; k++)
        {
            Lcolptr[k] = put;
            Lrowidx[put] = k;
            Lvalue_[put++] = 1.0;
            colptr[p[k]] = put; /* next free position in column */
            put += Lbegin_p[k+1] - Lbegin_p[k] - 1;
            /* subtract 1 because internal storage uses (-1) terminators */
        }
        Lcolptr[m] = put;
        assert(put == this.Lnz+m);

        for (k = 0; k < m; k++)
        {
            for (pos = Ltbegin_p[k]; (i = Lindex[pos]) >= 0; pos++)
            {
                put = colptr[i]++;
                Lrowidx[put] = k;
                Lvalue_[put] = Lvalue[pos];
            }
        }

        #ifndef NDEBUG
        for (k = 0; k < m; k++)
        {
            assert(colptr[p[k]] == Lcolptr[k+1]);
        }
        #endif
    }

    if (Ucolptr && Urowidx && Uvalue_)
    {
        const lu_int *Wbegin    = this.Wbegin;
        const lu_int *Wend      = this.Wend;
        const lu_int *Windex    = this.Windex;
        const double *Wvalue    = this.Wvalue;
        const double *col_pivot = this.col_pivot;
        const lu_int *pivotcol  = this.pivotcol;
        lu_int *colptr          = this.iwork1; /* size m workspace */
        lu_int j, k, put, pos;

        /*
         * U[:,k] will hold the column of B from the k-th pivot step.
         * First set the column pointers and store the pivot element at the end
         * of each column. Then scatter each row of U' into the columnwise U so
         * that the row indices become sorted.
         */
        memset(colptr, 0, m*sizeof(lu_int)); /* column counts */
        for (j = 0; j < m; j++)
        {
            for (pos = Wbegin[j]; pos < Wend[j]; pos++)
                colptr[Windex[pos]]++;
        }
        put = 0;
        for (k = 0; k < m; k++) /* set column pointers */
        {
            j = pivotcol[k];
            Ucolptr[k] = put;
            put += colptr[j];
            colptr[j] = Ucolptr[k]; /* next free position in column */
            Urowidx[put] = k;
            Uvalue_[put++] = col_pivot[j];
        }
        Ucolptr[m] = put;
        assert(put == this.Unz+m);
        for (k = 0; k < m; k++) /* scatter row k */
        {
            j = pivotcol[k];
            for (pos = Wbegin[j]; pos < Wend[j]; pos++)
            {
                put = colptr[Windex[pos]]++;
                Urowidx[put] = k;
                Uvalue_[put] = Wvalue[pos];
            }
        }

        #ifndef NDEBUG
        for (k = 0; k < m; k++) assert(colptr[pivotcol[k]] == Ucolptr[k+1]-1);
        for (k = 0; k < m; k++) assert(Urowidx[Ucolptr[k+1]-1] == k);
        #endif
    }

    return BASICLU_OK;
}