Package: ROI.plugin.highs
Check: tests
New result: ERROR
    Running ‘test_highs.R’ [1s/1s]
  Running the tests in ‘tests/test_highs.R’ failed.
  Complete output:
    > if (FALSE) {
    +     q("no")
    +     R
    + }
    > 
    > Sys.setenv("ROI_LOAD_PLUGINS" = FALSE)
    > library("ROI")
    ROI: R Optimization Infrastructure
    Registered solver plugins: nlminb.
    Default solver: auto.
    > library("ROI.plugin.highs")
    > 
    > 
    > check <- function(domain, condition, level=1, message="", call=sys.call(-1L)) {
    +     if ( isTRUE(condition) ) return(invisible(NULL))
    +     msg <- sprintf("in %s", domain)
    +     if ( all(nchar(message) > 0) ) msg <- sprintf("%s\n\t%s", msg, message)
    +     stop(msg)
    +     return(invisible(NULL))
    + }
    > 
    > 
    > ## LP - Example - 1
    > ## max:  2 x_1 + 4 x_2 + 3 x_3
    > ## s.t.
    > ## 3 x_1  +  4 x_2  +  2 x_3  <= 60
    > ## 2 x_1  +    x_2  +  2 x_3  <= 40
    > ##   x_1  +  3 x_2  +  2 x_3  <= 80 
    > ## x_1, x_2, x_3 >= 0
    > test_lp_01 <- function(solver) {
    +     mat <- matrix(c(3, 4, 2,
    +                     2, 1, 2,
    +                     1, 3, 2), nrow=3, byrow=TRUE)
    +     x <- OP(objective = c(2, 4, 3),
    +             constraints = L_constraint(L = mat,
    +                                        dir = c("<=", "<=", "<="),
    +                                        rhs = c(60, 40, 80)),
    +             bounds = V_bound(ui = seq_len(3), ub = c(1000, Inf, 1000), nobj = 3),
    +             maximum = TRUE)
    + 
    +     opt <- ROI_solve(x, solver = solver)
    +     check("LP-01@01", equal(opt$solution, c(0, 20/3, 50/3), tol=1e-4))
    +     check("LP-01@02", equal(opt$objval, 230/3, tol=1e-4))
    + 
    + 
    +     x <- OP(objective = c(2, 4, 3),
    +         constraints = L_constraint(L = mat,
    +                                    dir = c("<=", "<=", "<="),
    +                                    rhs = c(60, 40, 80)),
    +         maximum = TRUE)
    + 
    +     opt <- ROI_solve(x, solver = solver)
    +     check("LP-01@01", equal(opt$solution, c(0, 20/3, 50/3), tol=1e-4))
    +     check("LP-01@02", equal(opt$objval, 230/3, tol=1e-4))
    + }
    > 
    > ## Test if ROI can handle empty constraint matrix.
    > test_lp_02 <- function(solver) {
    +     x <- OP(objective = c(2, 4, 3),
    +             constraints = L_constraint(L=matrix(0, nrow=0, ncol=3), 
    +                                        dir=character(), rhs=double()),
    +             maximum = FALSE)
    + 
    +     opt <- ROI_solve(x, solver = solver)
    +     check("LP-02@01", equal(opt$solution, c(0, 0, 0), tol=1e-4))
    +     check("LP-02@02", equal(opt$objval, 0, tol=1e-4))
    + }
    > 
    > ## Test if ROI can handle when the constraint is equal to NULL.
    > test_lp_03 <- function(solver) {
    +     x <- OP(objective = c(2, 4, 3), constraints = NULL, maximum = FALSE)
    + 
    +     opt <- ROI_solve(x, solver = solver)
    +     check("LP-03@03", equal(opt$solution, c(0, 0, 0), tol=1e-4))
    +     check("LP-03@03", equal(opt$objval, 0, tol=1e-4))
    + }
    > 
    > ## MILP - Example - 1
    > ## min:  3 x + 1 y + 3 z
    > ## s.t.
    > ##      -1 x  +    y  +   z  <=  4
    > ##               4 y  - 3 z  <=  2
    > ##         x  -  3 y  + 2 z  <=  3
    > ##     x, z \in Z_+
    > ##     y >= 0
    > test_milp_01 <- function(solver) {
    +     obj <- c(3, 1, 3)
    +     A <- rbind(c(-1,  2,  1),
    +                c( 0,  4, -3),
    +                c( 1, -3,  2))
    +     b <- c(4, 2, 3)
    +     bounds <- V_bound(li = c(1L, 3L), ui = c(1L, 2L),
    +                   lb = c(-Inf, 2), ub = c(4, 100))
    + 
    +     x <- OP(objective = obj,
    +          constraints = L_constraint(L = A,
    +                                     dir = c("<=", "<=", "<="),
    +                                     rhs = b),
    +          types = c("I", "C", "I"),
    +          bounds = bounds,
    +          maximum = TRUE)
    + 
    +     control <- list()
    +     opt <- ROI_solve(x, solver=solver, control=control)
    + 
    +     check("MILP-01@01", equal(opt$solution , c(4, 2.5, 3), tol=1e-01))
    + }
    > 
    > ## MILP - Example - 2
    > ## min:  3 x + 1 y + 3 z
    > ## s.t.
    > ##      -1 x  +    y  +   z  <=  4
    > ##               4 y  - 3 z  <=  2
    > ##         x  -  3 y  + 2 z  <=  3
    > ##     x, z \in Z_+
    > ##     y >= 0
    > test_milp_02 <- function(solver) {
    +     obj <- c(3, 1, 3)
    +     A <- rbind(c(-1,  2,  1),
    +                c( 0,  4, -3),
    +                c( 1, -3,  2))
    +     b <- c(4, 2, 3)
    + 
    +     x <- OP(objective = obj,
    +          constraints = L_constraint(L = A,
    +                                     dir = c("<=", "<=", "<="),
    +                                     rhs = b),
    +          types = c("I", "C", "I"),
    +          maximum = TRUE)
    + 
    +     opt <- ROI_solve(x, solver=solver)
    +     check("MILP-02@01", all(A %*% opt$solution <= b))
    +     check("MILP-02@01", equal(opt$solution , c(5, 2.75, 3), tol=1e-01))
    + }
    > 
    > ## LP - Multiple Solutions
    > ## solver <- "msbinlp"
    > test_blp_multisol_01 <- function(solver) {
    +     x <- OP(objective = c(1, 1),
    +             constraints = L_constraint(c(1, 1), "==", 1),
    +             types = c("B", "B"))
    + 
    +     opt <- ROI_solve(x, solver = solver)
    + 
    +     sol <- solution(opt)
    +     solver <- "lpsolve"
    +     check("BLPMS-01@03", (equal(sol, c(1, 0)) || equal(sol, c(0, 1))))
    + }
    > 
    > 
    > ## QP - Example - 1
    > ##
    > ## from the quadprog package
    > ## (c) S original by Berwin A. Turlach R port by Andreas Weingessel
    > ## GPL-3
    > ##
    > ## min: -(0 5 0) %*% x + 1/2 x^T x
    > ## under the constraints:      A^T x >= b
    > ## with b = (-8,2,0)^T
    > ## and      (-4  2  0)
    > ##      A = (-3  1 -2)
    > ##          ( 0  0  1)
    > ## we can use solve.QP as follows:
    > ##
    > ## library(quadprog)
    > ## D <- diag(1, 3)
    > ## d <- c(0, 5, 0)
    > ## A <- cbind(c(-4, -3, 0), 
    > ##            c( 2,  1, 0), 
    > ##            c( 0, -2, 1))
    > ## b <- c(-8, 2, 0)
    > ## 
    > ## sol <- solve.QP(D, d, A, bvec=b)
    > ## deparse(sol$solution)
    > ## deparse(sol$value)
    > test_qp_01 <- function(solver) {
    +     A <- cbind(c(-4, -3, 0), 
    +                c( 2,  1, 0), 
    +                c( 0, -2, 1))
    +     x <- OP(Q_objective(diag(3), L =  c(0, -5, 0)),
    +             L_constraint(L = t(A),
    +                          dir = rep(">=", 3),
    +                          rhs = c(-8, 2, 0)))
    + 
    +     opt <- ROI_solve(x, solver = solver)
    +     solution <- c(0.476190476190476, 1.04761904761905, 2.0952380952381)
    +     check("QP-01@01", equal(opt$solution, solution) )
    +     check("QP-01@02", equal(opt$objval, -2.38095238095238) )
    + }
    > 
    > ## This Test detects non-conform objective functions.
    > ## minimize 0.5 x^2 - 2 x + y
    > ## s.t. x <= 3
    > ## Type 1:   0.5 x'Qx + c'Lx => c(2, 0)  objval=-2
    > ## Type 2:       x'Qx + c'Lx => c(3, 0)  objval=-3.75
    > test_qp_02 <- function(solver) {
    +     zero <- .Machine$double.eps * 100
    +     qo <- Q_objective(Q=rbind(c(1, 0), c(0, zero)), L=c(-2, 1))
    +     lc1 <- L_constraint(L=matrix(c(1, 0), nrow=1), dir="<=", rhs=3)
    +     lc2 <- L_constraint(L=matrix(c(1, 0), nrow=1), dir=">=", rhs=0)
    +     x <- OP(qo, c(lc1, lc2))
    + 
    +     opt <- ROI_solve(x, solver=solver)
    +     solution <- c(2, 0)
    +     check("QP-02@01", equal(opt$solution, solution) )
    +     check("QP-02@02", equal(opt$objval, -2) )
    + }
    > 
    > ## as qp_01 but maximize
    > test_qp_03 <- function(solver) {
    +     A <- cbind(c(-4, -3, 0), 
    +                c( 2,  1, 0), 
    +                c( 0, -2, 1))
    +     x <- OP(Q_objective(-diag(3), L = -c(0, -5, 0)),
    +             L_constraint(L = t(A),
    +                          dir = rep(">=", 3),
    +                          rhs = c(-8, 2, 0)),
    +             maximum = TRUE)
    + 
    +     opt <- ROI_solve(x, solver=solver)
    +     solution <- c(0.476190476190476, 1.04761904761905, 2.0952380952381)
    +     check("QP-01@01", equal(opt$solution, solution) )
    +     check("QP-01@02", equal(opt$objval, 2.38095238095238) )
    + }
    > 
    > 
    > if ( !any("highs" %in% names(ROI_registered_solvers())) ) {
    +     ## This should never happen.
    +     message("ROI.plugin.highs cloud not be found among the registered solvers.\n")
    + } else {
    +     solver <- "highs"
    +     message("Start Testing!")
    +     local({test_lp_01(solver)})
    +     local({test_lp_02(solver)})
    +     local({test_lp_03(solver)})
    +     local({test_milp_01(solver)})
    +     local({test_milp_02(solver)})
    +     local({test_qp_01(solver)})
    +     local({test_qp_01(solver)})
    +     local({test_qp_02(solver)})
    +     local({test_qp_03(solver)})
    + }
    Start Testing!
    Error in check("MILP-01@01", equal(opt$solution, c(4, 2.5, 3), tol = 0.1)) : 
      in MILP-01@01
    Calls: local ... eval -> eval -> eval -> eval -> test_milp_01 -> check
    Execution halted