lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/basiclu_solve_for_update.h

@@ -0,0 +1,169 @@
+lu_int basiclu_solve_for_update
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    lu_int nzrhs,
+    const lu_int irhs[],
+    const double xrhs[],
+    lu_int *p_nzlhs,
+    lu_int ilhs[],
+    double lhs[],
+    char trans
+);
+
+/*
+Purpose:
+
+    Given the factorization computed by basiclu_factorize() or basiclu_update(),
+    solve a linear system in preparation to update the factorization.
+
+    When the forward system is solved, then the right-hand side is the column
+    to be inserted into the factorized matrix. When the transposed system is
+    solved, then the right-hand side is a unit vector with entry 1 in position
+    of the column to be replaced in the factorized matrix.
+
+    For BASICLU to prepare the update, it is sufficient to compute only a
+    partial solution. If the left-hand side is not requested by the user (see
+    below), then only one triangular solve is done. If the left-hand side is
+    requested, then a second triangular solve is required.
+
+Return:
+
+    BASICLU_ERROR_invalid_store if istore, xstore do not hold a BASICLU
+    instance. In this case xstore[BASICLU_STATUS] is not set.
+
+    Otherwise return the status code. See xstore[BASICLU_STATUS] below.
+
+Arguments:
+
+    lu_int istore[]
+    double xstore[]
+    lu_int Li[]
+    double Lx[]
+    lu_int Ui[]
+    double Ux[]
+    lu_int Wi[]
+    double Wx[]
+
+        Factorization computed by basiclu_factorize() or basiclu_update().
+
+    lu_int nzrhs
+    const lu_int irhs[nzrhs]
+    const double xrhs[nzrhs]
+
+        The right-hand side vector in compressed format.
+
+        When the forward system is solved, irhs[0..nzrhs-1] are the indices of
+        nonzeros and xrhs[0..nzrhs-1] the corresponding values. irhs must not
+        contain duplicates.
+        
+        When the transposed system is solved, the right-hand side is a unit
+        vector with entry 1 in position irhs[0]. nzrhs, xrhs and elements of
+        irhs other than irhs[0] are not accessed. xrhs can be NULL.
+
+    lu_int *p_nzlhs
+    lu_int ilhs[m]
+    lu_int lhs[m]
+
+        If any of p_nzlhs, ilhs or lhs is NULL, then the solution to the linear
+        system is not requested. In this case only the update is prepared.
+
+        Otherwise:
+
+        *p_nzlhs is uninitialized on entry. On return *p_nzlhs holds
+        the number of nonzeros in the solution.
+        The contents of ilhs is uninitialized on entry. On return
+        ilhs[0..*p_nzlhs-1] holds the indices of nonzeros in the solution.
+        The contents of lhs must be initialized to zero on entry. On return
+        the solution is  scattered into lhs.
+
+    char trans
+
+        Defines which system to solve. 't' or 'T' for the transposed system,
+        any other character for the forward system.
+
+Parameters:
+
+    xstore[BASICLU_MEMORYL]: length of Li and Lx
+    xstore[BASICLU_MEMORYU]: length of Ui and Ux
+    xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+    xstore[BASICLU_SPARSE_THRESHOLD]
+
+        Defines which method is used for solving a triangular system. A
+        triangular solve can be done either by the two phase method of Gilbert
+        and Peierls ("sparse solve") or by a sequential pass through the vector
+        ("sequential solve").
+
+        When the solution to the linear system is requested, then two triangular
+        systems are solved. The first triangular solve is done sparse. The
+        second triangular solve is done sparse if its right-hand side has not
+        more than m * xstore[BASICLU_SPARSE_THRESHOLD] nonzeros. Otherwise the
+        sequential solve is used.
+
+        When the solution to the linear system is not requested, then this
+        parameter has no effect.
+
+        Default: 0.05
+
+    xstore[BASICLU_DROP_TOLERANCE]
+
+        Nonzeros which magnitude is less than or equal to the drop tolerance
+        are removed after each triangular solve. Default: 1e-20
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The updated has been successfully prepared and, if requested, the
+            solution to the linear system has been computed.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the mandatory pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            The factorization is invalid.
+
+        BASICLU_ERROR_maximum_updates
+
+            There have already been m Forrest-Tomlin updates, see
+            xstore[BASICLU_NFORREST]. The factorization cannot be updated any
+            more and must be recomputed by basiclu_factorize().
+            The solution to the linear system has not been computed.
+
+        BASICLU_ERROR_invalid_argument
+
+            The right-hand side is invalid (forward system: nzrhs < 0 or
+            nzrhs > m or one or more indices out of range; backward system:
+            irhs[0] out of range).
+
+        BASICLU_REALLOCATE
+
+            The solve was aborted because of insufficient memory in Li,Lx or
+            Ui,Ux to store data for basiclu_update(). The number of additional
+            elements required is given by
+
+                xstore[BASICLU_ADD_MEMORYL] >= 0
+                xstore[BASICLU_ADD_MEMORYU] >= 0
+
+            The user must reallocate the arrays for which additional memory is
+            required. It is recommended to reallocate for the requested number
+            of additional elements plus some extra space for further updates
+            (e.g. 0.5 times the current array length). The new array lengths
+            must be provided in
+
+                xstore[BASICLU_MEMORYL]: length of Li and Lx
+                xstore[BASICLU_MEMORYU]: length of Ui and Ux
+
+            basiclu_solve_for_update() will start from scratch in the next call.
+*/

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/basiclu_solve_sparse.h

@@ -0,0 +1,112 @@
+lu_int basiclu_solve_sparse
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx [],
+    lu_int nzrhs,
+    const lu_int irhs[],
+    const double xrhs[],
+    lu_int *p_nzlhs,
+    lu_int ilhs[],
+    double lhs[],
+    char trans
+);
+
+/*
+Purpose:
+
+    Given the factorization computed by basiclu_factorize() or basiclu_update()
+    and the sparse right-hand side, rhs, solve a linear system for the solution
+    lhs.
+
+Return:
+
+    BASICLU_ERROR_invalid_store if istore, xstore do not hold a BASICLU
+    instance. In this case xstore[BASICLU_STATUS] is not set.
+
+    Otherwise return the status code. See xstore[BASICLU_STATUS] below.
+
+Arguments:
+
+    lu_int istore[]
+    double xstore[]
+    lu_int Li[]
+    double Lx[]
+    lu_int Ui[]
+    double Ux[]
+    lu_int Wi[]
+    double Wx[]
+
+        Factorization computed by basiclu_factorize() or basiclu_update().
+
+    lu_int nzrhs
+    const lu_int irhs[nzrhs]
+    const double xrhs[nzrhs]
+
+        The right-hand side vector in compressed format. irhs[0..nzrhs-1] are
+        the indices of nonzeros and xrhs[0..nzrhs-1] the corresponding values.
+        irhs must not contain duplicates.
+
+    lu_int *p_nzlhs
+    lu_int ilhs[m]
+    lu_int lhs[m]
+
+        *p_nzlhs is uninitialized on entry. On return *p_nzlhs holds
+        the number of nonzeros in the solution.
+        The contents of ilhs is uninitialized on entry. On return
+        ilhs[0..*p_nzlhs-1] holds the indices of nonzeros in the solution.
+        The contents lhs must be initialized to zero on entry. On return
+        the solution is scattered into lhs.
+
+    char trans
+
+        Defines which system to solve. 't' or 'T' for the transposed system,
+        any other character for the forward system.
+
+Parameters:
+
+    xstore[BASICLU_SPARSE_THRESHOLD]
+
+        Defines which method is used for solving a triangular system. A
+        triangular solve can be done either by the two phase method of Gilbert
+        and Peierls ("sparse solve") or by a sequential pass through the vector
+        ("sequential solve").
+
+        Solving B*x=b requires two triangular solves. The first triangular solve
+        is done sparse. The second triangular solve is done sparse if its
+        right-hand side has not more than m * xstore[BASICLU_SPARSE_THRESHOLD]
+        nonzeros. Otherwise the sequential solve is used.
+
+        Default: 0.05
+
+    xstore[BASICLU_DROP_TOLERANCE]
+
+        Nonzeros which magnitude is less than or equal to the drop tolerance
+        are removed after each triangular solve. Default: 1e-20
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The linear system has been successfully solved.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            The factorization is invalid.
+
+        BASICLU_ERROR_invalid_argument
+
+            The right-hand side is invalid (nzrhs < 0 or nzrhs > m or one or
+            more indices out of range).
+*/

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/basiclu_update.h

@@ -0,0 +1,125 @@
+lu_int basiclu_update
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    double xtbl
+);
+
+/*
+Purpose:
+
+    Update the factorization to replace one column of the factorized matrix.
+    A call to basiclu_update() must be preceded by calls to
+    basiclu_solve_for_update() to provide the column to be inserted and the
+    index of the column to be replaced.
+
+    The column to be inserted is defined as the right-hand side in the last call
+    to basiclu_solve_for_update() in which the forward system was solved.
+
+    The index of the column to be replaced is defined by the unit vector in the
+    last call to basiclu_solve_for_update() in which the transposed system was
+    solved.
+
+Return:
+
+    BASICLU_ERROR_invalid_store if istore, xstore do not hold a BASICLU
+    instance. In this case xstore[BASICLU_STATUS] is not set.
+
+    Otherwise return the status code. See xstore[BASICLU_STATUS] below.
+
+Arguments:
+
+    lu_int istore[]
+    double xstore[]
+    lu_int Li[]
+    double Lx[]
+    lu_int Ui[]
+    double Ux[]
+    lu_int Wi[]
+    double Wx[]
+
+        Factorization computed by basiclu_factorize() or basiclu_update().
+
+    double xtbl
+
+        This is an optional argument to monitor numerical stability. xtbl can be
+        either of
+
+        (a) element j0 of the solution to the forward system computed by
+            basiclu_solve_for_update(), where j0 is the column to be replaced;
+
+        (b) the dot product of the incoming column and the solution to the
+            transposed system computed by basiclu_solve_for_update().
+
+        In either case xstore[BASICLU_PIVOT_ERROR] (see below) has a defined
+        value. If monitoring stability is not desired, xtbl can be any value.
+
+Parameters:
+
+    xstore[BASICLU_MEMORYL]: length of Li and Lx
+    xstore[BASICLU_MEMORYU]: length of Ui and Ux
+    xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+    xstore[BASICLU_DROP_TOLERANCE]
+
+        Nonzeros which magnitude is less than or equal to the drop tolerance
+        are removed from the row eta matrix. Default: 1e-20
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The update has successfully completed.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            The factorization is invalid or the update was not prepared by two
+            calls to basiclu_solve_for_update().
+
+        BASICLU_REALLOCATE
+
+            Insufficient memory in Wi,Wx. The number of additional elements
+            required is given by
+
+                xstore[BASICLU_ADD_MEMORYW] > 0
+
+            The user must reallocate Wi,Wx. It is recommended to reallocate for
+            the requested number of additional elements plus some extra space
+            for further updates (e.g. 0.5 times the current array length). The
+            new array length must be provided in
+
+                xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+            basiclu_update will start from scratch in the next call.
+
+        BASICLU_ERROR_singular_update
+
+            The updated factorization would be (numerically) singular. No update
+            has been computed and the old factorization is still valid.
+
+    xstore[BASICLU_PIVOT_ERROR]
+
+        When xtbl was given (see above), then xstore[BASICLU_PIVOT_ERROR] is a
+        measure for numerical stability. It is the difference between two
+        computations of the new pivot element relative to the new pivot element.
+        A value larger than 1e-10 indicates numerical instability and suggests
+        refactorization (and possibly tightening the pivot tolerance).
+
+    xstore[BASICLU_MAX_ETA]
+
+        The maximum entry (in absolute value) in the eta vectors from the
+        Forrest-Tomlin update. A large value, say > 1e6, indicates that pivoting
+        on diagonal element was unstable and refactorization might be necessary.
+*/

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/lu_def.h

@@ -0,0 +1,39 @@
+#ifndef _LU_DEF_H
+#define _LU_DEF_H
+
+/* -------------------------------------------------------------------------- */
+/* ANSI standard include files */
+/* -------------------------------------------------------------------------- */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdint.h>
+#include <assert.h>
+
+#include "ipm/basiclu/basiclu.h"
+
+#define BASICLU_HASH 7743090    /* hash in istore[0], xstore[0] */
+
+enum { NO_TASK, SINGLETONS, SETUP_BUMP, FACTORIZE_BUMP, BUILD_FACTORS };
+
+/* -------------------------------------------------------------------------- */
+/* standard macros and inlines */
+/* -------------------------------------------------------------------------- */
+
+#define MAX(a,b) ((a)>=(b) ? (a):(b))
+#define MIN(a,b) ((a)<=(b) ? (a):(b))
+
+static inline void lu_iswap(lu_int *x, lu_int i, lu_int j)
+{
+    lu_int t = x[i]; x[i] = x[j]; x[j] = t;
+}
+
+static inline void lu_fswap(double *x, lu_int i, lu_int j)
+{
+    double t = x[i]; x[i] = x[j]; x[j] = t;
+}
+
+#endif

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/lu_file.h

@@ -0,0 +1,21 @@
+#ifndef _LU_FILE_H
+#define _LU_FILE_H
+
+void lu_file_empty(
+    lu_int nlines, lu_int *begin, lu_int *end, lu_int *next, lu_int *prev,
+    lu_int fmem);
+
+void lu_file_reappend(
+    lu_int line, lu_int nlines, lu_int *begin, lu_int *end, lu_int *next,
+    lu_int *prev, lu_int *index, double *value, lu_int extra_space);
+
+lu_int lu_file_compress(
+    lu_int nlines, lu_int *begin, lu_int *end, const lu_int *next,
+    lu_int *index, double *value, double stretch, lu_int pad);
+
+lu_int lu_file_diff(
+    lu_int nrow, const lu_int *begin_row, const lu_int *end_row,
+    const lu_int *begin_col, const lu_int *end_col, const lu_int *index,
+    const double *value);
+
+#endif

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/lu_internal.h

@@ -0,0 +1,220 @@
+#ifndef _LU_INTERNAL_H
+#define _LU_INTERNAL_H
+
+#include "ipm/basiclu/lu_def.h"
+
+/* -------------------------------------------------------------------------- */
+/* struct lu */
+/* -------------------------------------------------------------------------- */
+
+/*
+    This data structure provides access to istore, xstore.
+
+    lu_* routines do not access istore, xstore directly. Instead, they operate
+    on a struct lu object. Scalar quantities stored in istore, xstore are copied
+    to a struct lu object by lu_load() and copied back by lu_save(). Subarrays
+    of istore, xstore and the user arrays Li, Lx, Ui, Ux, Wi, Wx are aliased by
+    pointers in struct lu.
+*/
+
+struct lu
+{
+    /* user parameters, not modified */
+    lu_int Lmem;
+    lu_int Umem;
+    lu_int Wmem;
+    double droptol;
+    double abstol;
+    double reltol;
+    lu_int nzbias;
+    lu_int maxsearch;
+    lu_int pad;
+    double stretch;
+    double compress_thres;
+    double sparse_thres;
+    lu_int search_rows;
+
+    /* user readable */
+    lu_int m;
+    lu_int addmemL;
+    lu_int addmemU;
+    lu_int addmemW;
+
+    lu_int nupdate;
+    lu_int nforrest;
+    lu_int nfactorize;
+    lu_int nupdate_total;
+    lu_int nforrest_total;
+    lu_int nsymperm_total;
+    lu_int Lnz;                  /* nz in L excluding diagonal */
+    lu_int Unz;                  /* nz in U excluding diagonal */
+    lu_int Rnz;                  /* nz in update etas excluding diagonal */
+    double min_pivot;
+    double max_pivot;
+    double max_eta;
+    double update_cost_numer;
+    double update_cost_denom;
+    double time_factorize;
+    double time_solve;
+    double time_update;
+    double time_factorize_total;
+    double time_solve_total;
+    double time_update_total;
+    lu_int Lflops;
+    lu_int Uflops;
+    lu_int Rflops;
+    double condestL;
+    double condestU;
+    double normL;
+    double normU;
+    double normestLinv;
+    double normestUinv;
+    double onenorm;             /* 1-norm and inf-norm of matrix after fresh  */
+    double infnorm;             /* factorization with dependent cols replaced */
+    double residual_test;       /* computed by lu_residual_test() */
+
+    lu_int matrix_nz;           /* nz in basis matrix when factorized */
+    lu_int rank;                /* rank of basis matrix when factorized */
+    lu_int bump_size;
+    lu_int bump_nz;
+    lu_int nsearch_pivot;       /* # rows/cols searched for pivot */
+    lu_int nexpand;             /* # rows/cols expanded in factorize */
+    lu_int ngarbage;            /* # garbage collections in factorize */
+    lu_int factor_flops;        /* # flops in factorize */
+    double time_singletons;
+    double time_search_pivot;
+    double time_elim_pivot;
+
+    double pivot_error;         /* error estimate for pivot in last update */
+
+    /* private */
+    lu_int task;                /* the part of factorization in progress */
+    lu_int pivot_row;           /* chosen pivot row */
+    lu_int pivot_col;           /* chosen pivot column */
+    lu_int ftran_for_update;    /* >= 0 if FTRAN prepared for update */
+    lu_int btran_for_update;    /* >= 0 if BTRAN prepared for update */
+    lu_int marker;              /* see @marked, below */
+    lu_int pivotlen;            /* length of @pivotcol, @pivotrow; <= 2*m */
+    lu_int rankdef;             /* # columns removed from active submatrix
+                                   because maximum was 0 or < abstol */
+    lu_int min_colnz;           /* colcount lists 1..min_colnz-1 are empty */
+    lu_int min_rownz;           /* rowcount lists 1..min_rownz-1 are empty */
+
+    /* aliases to user arrays */
+    lu_int *Lindex, *Uindex, *Windex;
+    double *Lvalue, *Uvalue, *Wvalue;
+
+    /*
+     * pointers into istore
+     *
+     * When two declaration lists are on one line, then the arrays from the
+     * second list share memory with the array from the first list. The arrays
+     * from the first lists are used during factorization, the arrays from the
+     * second lists are used during solves/updates.
+     */
+
+    /* documented in lu_singletons.c, lu_setup_bump.c, lu_build_factors.c */
+    lu_int *colcount_flink;     lu_int *pivotcol;
+    lu_int *colcount_blink;     lu_int *pivotrow;
+    lu_int *rowcount_flink;     lu_int *Rbegin, *eta_row;
+    lu_int *rowcount_blink;     lu_int *iwork1;
+    lu_int *Wbegin;             lu_int *Lbegin;    /* + Wbegin reused */
+    lu_int *Wend;               lu_int *Ltbegin;   /* + Wend   reused */
+    lu_int *Wflink;             lu_int *Ltbegin_p; /* + Wflink reused */
+    lu_int *Wblink;             lu_int *p;         /* + Wblink reused */
+    lu_int *pinv;               lu_int *pmap;
+    lu_int *qinv;               lu_int *qmap;
+    lu_int *Lbegin_p;           /* Lbegin_p reused */
+    lu_int *Ubegin;             /* Ubegin   reused */
+
+    lu_int *iwork0;             lu_int *marked;
+    /* iwork0: size m workspace, zeroed */
+    /* marked: size m workspace, 0 <= marked[i] <= @marker */
+
+    /* pointers into xstore */
+    double *work0;              /* size m workspace, zeroed */
+    double *work1;              /* size m workspace, uninitialized */
+    double *col_pivot;          /* pivot elements by column index */
+    double *row_pivot;          /* pivot elements by row index */
+};
+
+
+/* -------------------------------------------------------------------------- */
+/* Internal function prototypes */
+/* -------------------------------------------------------------------------- */
+
+lu_int lu_load(
+    struct lu *this, lu_int *istore, double *xstore, lu_int *Li, double *Lx,
+    lu_int *Ui, double *Ux, lu_int *Wi, double *Wx);
+
+lu_int lu_save(
+    const struct lu *this, lu_int *istore, double *xstore, lu_int status);
+
+void lu_reset(struct lu *this);
+
+void lu_initialize(lu_int m, lu_int *istore, double *xstore);
+
+lu_int lu_factorize_bump (struct lu *this);
+
+lu_int lu_build_factors(struct lu *this);
+
+void lu_garbage_perm(struct lu *this);
+
+lu_int lu_markowitz(struct lu *this);
+
+lu_int lu_pivot(struct lu *this);
+
+lu_int lu_setup_bump(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+lu_int lu_singletons(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+void lu_solve_dense(
+    struct lu *this, const double *rhs, double *lhs, char trans);
+
+lu_int lu_solve_for_update(
+    struct lu *this, const lu_int nrhs, const lu_int *irhs, const double *xrhs,
+    lu_int *nlhs, lu_int *ilhs, double *xlhs, char trans);
+
+void lu_solve_sparse(
+    struct lu *this, const lu_int nrhs, const lu_int *irhs, const double *xrhs,
+    lu_int *nlhs, lu_int *ilhs, double *xlhs, char trans);
+
+lu_int lu_dfs(
+    lu_int i, const lu_int *begin, const lu_int *end, const lu_int *index,
+    lu_int top, lu_int *xi, lu_int *pstack, lu_int *marked, const lu_int M);
+
+lu_int lu_solve_symbolic(
+    const lu_int m, const lu_int *begin, const lu_int *end, const lu_int *index,
+    const lu_int nrhs, const lu_int *irhs, lu_int *ilhs, lu_int *pstack,
+    lu_int *marked, const lu_int M);
+
+lu_int lu_solve_triangular(
+    const lu_int nz_symb, const lu_int *pattern_symb, const lu_int *begin,
+    const lu_int *end, const lu_int *index, const double *value,
+    const double *pivot, const double droptol, double *lhs, lu_int *pattern,
+    lu_int *flops);
+
+lu_int lu_update(struct lu *this, double xtbl);
+
+double lu_condest(
+    lu_int m, const lu_int *Ubegin, const lu_int *Ui, const double *Ux,
+    const double *pivot, const lu_int *perm, int upper, double *work,
+    double *norm, double *norminv);
+
+double lu_normest(
+    lu_int m, const lu_int *Ubegin, const lu_int *Ui, const double *Ux,
+    const double *pivot, const lu_int *perm, int upper, double *work);
+
+void lu_matrix_norm(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+void lu_residual_test(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+#endif