==4094804== Memcheck, a memory error detector ==4094804== Copyright (C) 2002-2026, and GNU GPL'd, by Julian Seward et al. ==4094804== Using Valgrind-3.27.1 and LibVEX; rerun with -h for copyright info ==4094804== Command: /data/localhost/ripley/R/R-devel-vg/bin/exec/R --vanilla ==4094804== R Under development (unstable) (2026-09-15 r90540) -- "Unsuffered Consequences" Copyright (C) 2026 The R Foundation for Statistical Computing Platform: x86_64-pc-linux-gnu R is free software and comes with ABSOLUTELY NO WARRANTY. You are welcome to redistribute it under certain conditions. Type 'license()' or 'licence()' for distribution details. Natural language support but running in an English locale R is a collaborative project with many contributors. Type 'contributors()' for more information and 'citation()' on how to cite R or R packages in publications. Type 'demo()' for some demos, 'help()' for on-line help, or 'help.start()' for an HTML browser interface to help. Type 'q()' to quit R. > pkgname <- "coinclp" > source(file.path(R.home("share"), "R", "examples-header.R")) > options(warn = 1) > library('coinclp') > > base::assign(".oldSearch", base::search(), pos = 'CheckExEnv') > base::assign(".old_wd", base::getwd(), pos = 'CheckExEnv') > cleanEx() > nameEx("addRowsCLP") > ### * addRowsCLP > > flush(stderr()); flush(stdout()) > > ### Name: addRowsCLP > ### Title: Add and delete rows and columns, clpAPI style > ### Aliases: addRowsCLP addColsCLP delRowsCLP delColsCLP > > ### ** Examples > > lp <- initProbCLP() > loadMatrixCLP(lp, 2, 0, c(0, 0, 0), integer(0), numeric(0)) > addRowsCLP(lp, 1, -1e30, 4, c(0, 2), c(0, 1), c(1, 1)) > getNumRowsCLP(lp) [1] 1 > delProbCLP(lp) > > > > cleanEx() > nameEx("clpPtr-accessors") > ### * clpPtr-accessors > > flush(stderr()); flush(stdout()) > > ### Name: clpPtr-accessors > ### Title: Accessors for clpPtr objects > ### Aliases: clpPtr-accessors clpPointer,clpPtr-method > ### clpPtrType,clpPtr-method clpPtrType<-,clpPtr,character-method > ### isNULLpointerCLP,clpPtr-method isCLPpointer,clpPtr-method > ### show,clpPtr-method clpPointer clpPtrType clpPtrType<- > ### isNULLpointerCLP isCLPpointer > > ### ** Examples > > lp <- initProbCLP() > clpPtrType(lp) [1] "clp_prob" > delProbCLP(lp) > > > > cleanEx() > nameEx("clpPtr-class") > ### * clpPtr-class > > flush(stderr()); flush(stdout()) > > ### Name: clpPtr-class > ### Title: A pointer to a Clp problem, clpAPI style > ### Aliases: clpPtr-class > > ### ** Examples > > lp <- initProbCLP() > isCLPpointer(lp) [1] TRUE > delProbCLP(lp) > > > > cleanEx() > nameEx("clp_add_rows") > ### * clp_add_rows > > flush(stderr()); flush(stdout()) > > ### Name: clp_add_rows > ### Title: Add or delete rows and columns > ### Aliases: clp_add_rows clp_add_columns clp_delete_rows > ### clp_delete_columns > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 0, start = c(0L, 0L, 0L), + index = integer(0), value = numeric(0), + obj = c(1, 1)) > clp_add_rows(model, 1, rowlb = -clp_inf(), rowub = 5, + rowstarts = c(0L, 2L), columns = c(0L, 1L), elements = c(1, 1)) > clp_num_rows(model) [1] 1 > clp_free(model) > > > > cleanEx() > nameEx("clp_col_solution") > ### * clp_col_solution > > flush(stderr()); flush(stdout()) > > ### Name: clp_col_solution > ### Title: Solution vectors > ### Aliases: clp_col_solution clp_reduced_costs clp_row_activity > ### clp_row_price clp_set_col_solution > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 1, c(0L, 1L, 2L), c(0L, 0L), c(1, 1), + obj = c(-1, -1), rowub = 1) > clp_initial_solve(model) [1] 0 > clp_col_solution(model) [1] 1 0 > clp_row_price(model) [1] -1 > clp_free(model) > > > > cleanEx() > nameEx("clp_control") > ### * clp_control > > flush(stderr()); flush(stdout()) > > ### Name: clp_control > ### Title: Control parameters for clp_solve() > ### Aliases: clp_control > > ### ** Examples > > clp_control(algorithm = "dual", max_seconds = 10) $log_level [1] 0 $algorithm [1] "dual" $presolve [1] TRUE $max_iterations NULL $max_seconds [1] 10 $primal_tolerance NULL $dual_tolerance NULL $scaling NULL attr(,"class") [1] "clp_control" > > > > cleanEx() > nameEx("clp_free") > ### * clp_free > > flush(stderr()); flush(stdout()) > > ### Name: clp_free > ### Title: Release a Clp model > ### Aliases: clp_free > > ### ** Examples > > model <- clp_model() > clp_free(model) > clp_is_open(model) [1] FALSE > > > > cleanEx() > nameEx("clp_inf") > ### * clp_inf > > flush(stderr()); flush(stdout()) > > ### Name: clp_inf > ### Title: The value Clp treats as infinite > ### Aliases: clp_inf > > ### ** Examples > > clp_inf() [1] 1e+30 > > > > cleanEx() > nameEx("clp_initial_solve") > ### * clp_initial_solve > > flush(stderr()); flush(stdout()) > > ### Name: clp_initial_solve > ### Title: Solve a loaded model > ### Aliases: clp_initial_solve clp_initial_dual_solve > ### clp_initial_primal_solve clp_initial_barrier_solve > ### clp_initial_barrier_no_cross_solve clp_initial_solve_with_options > ### clp_primal_simplex clp_dual_simplex clp_idiot clp_crash > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 1, c(0L, 1L, 2L), c(0L, 0L), c(1, 1), + obj = c(-1, -2), rowub = 3) > clp_set_log_level(model, 0L) > clp_initial_solve(model) [1] 0 > clp_objective_value(model) [1] -6 > clp_free(model) > > > > cleanEx() > nameEx("clp_is_open") > ### * clp_is_open > > flush(stderr()); flush(stdout()) > > ### Name: clp_is_open > ### Title: Is a model still usable? > ### Aliases: clp_is_open > > ### ** Examples > > model <- clp_model() > clp_is_open(model) [1] TRUE > > > > cleanEx() > nameEx("clp_is_proven_optimal") > ### * clp_is_proven_optimal > > flush(stderr()); flush(stdout()) > > ### Name: clp_is_proven_optimal > ### Title: Feasibility and optimality flags > ### Aliases: clp_is_proven_optimal clp_is_proven_primal_infeasible > ### clp_is_proven_dual_infeasible clp_is_abandoned > ### clp_is_primal_objective_limit_reached > ### clp_is_dual_objective_limit_reached clp_is_iteration_limit_reached > ### clp_primal_feasible clp_dual_feasible > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, obj = 1, rowlb = 1) > clp_initial_solve(model) [1] 0 > clp_is_proven_optimal(model) [1] TRUE > clp_free(model) > > > > cleanEx() > nameEx("clp_load_problem") > ### * clp_load_problem > > flush(stderr()); flush(stdout()) > > ### Name: clp_load_problem > ### Title: Load a problem into a Clp model > ### Aliases: clp_load_problem > > ### ** Examples > > # maximise 2x + 3y subject to x + y <= 4, x + 3y <= 6 > model <- clp_model() > clp_load_problem(model, ncols = 2, nrows = 2, + start = c(0L, 2L, 4L), + index = c(0L, 1L, 0L, 1L), + value = c(1, 1, 1, 3), + collb = c(0, 0), colub = c(clp_inf(), clp_inf()), + obj = c(-2, -3), + rowlb = c(-clp_inf(), -clp_inf()), rowub = c(4, 6)) > clp_initial_solve(model) [1] 0 > clp_col_solution(model) [1] 3 1 > clp_free(model) > > > > cleanEx() > nameEx("clp_load_quadratic_objective") > ### * clp_load_quadratic_objective > > flush(stderr()); flush(stdout()) > > ### Name: clp_load_quadratic_objective > ### Title: Load a quadratic objective > ### Aliases: clp_load_quadratic_objective > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 0, start = c(0L, 0L), index = integer(0), + value = numeric(0)) > clp_load_quadratic_objective(model, 1, c(0L, 1L), 0L, 2) > clp_free(model) > > > > cleanEx() > nameEx("clp_log_level") > ### * clp_log_level > > flush(stderr()); flush(stdout()) > > ### Name: clp_log_level > ### Title: Algorithm settings > ### Aliases: clp_log_level clp_set_log_level clp_scaling clp_set_scaling > ### clp_perturbation clp_set_perturbation clp_algorithm clp_set_algorithm > ### clp_iterations clp_set_iterations > > ### ** Examples > > model <- clp_model() > clp_set_log_level(model, 0L) > clp_log_level(model) [1] 0 > clp_free(model) > > > > cleanEx() > nameEx("clp_matrix") > ### * clp_matrix > > flush(stderr()); flush(stdout()) > > ### Name: clp_matrix > ### Title: The constraint matrix > ### Aliases: clp_matrix clp_vector_starts clp_vector_lengths clp_indices > ### clp_elements > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 1, c(0L, 1L, 2L), c(0L, 0L), c(1, 2), rowub = 3) > clp_matrix(model) $i [1] 1 1 $j [1] 1 2 $v [1] 1 2 $nrow [1] 1 $ncol [1] 2 > clp_free(model) > > > > cleanEx() > nameEx("clp_model") > ### * clp_model > > flush(stderr()); flush(stdout()) > > ### Name: clp_model > ### Title: Create a Clp model > ### Aliases: clp_model > > ### ** Examples > > model <- clp_model() > clp_num_cols(model) [1] 0 > clp_free(model) > > > > cleanEx() > nameEx("clp_modify_coefficient") > ### * clp_modify_coefficient > > flush(stderr()); flush(stdout()) > > ### Name: clp_modify_coefficient > ### Title: Change one matrix coefficient > ### Aliases: clp_modify_coefficient > > ### ** Examples > > if (isTRUE(clp_features()[["modify_coefficient"]])) { + model <- clp_model() + clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, rowub = 1) + clp_modify_coefficient(model, 0, 0, 2) + clp_free(model) + } > > > > cleanEx() > nameEx("clp_num_rows") > ### * clp_num_rows > > flush(stderr()); flush(stdout()) > > ### Name: clp_num_rows > ### Title: Size of a model > ### Aliases: clp_num_rows clp_num_cols clp_num_elements > > ### ** Examples > > model <- clp_model() > clp_resize(model, 3, 4) > c(clp_num_rows(model), clp_num_cols(model)) [1] 3 4 > clp_free(model) > > > > cleanEx() > nameEx("clp_objective") > ### * clp_objective > > flush(stderr()); flush(stdout()) > > ### Name: clp_objective > ### Title: Bounds and objective coefficients > ### Aliases: clp_objective clp_col_lower clp_col_upper clp_row_lower > ### clp_row_upper clp_set_objective clp_set_col_lower clp_set_col_upper > ### clp_set_row_lower clp_set_row_upper > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 0, start = c(0L, 0L, 0L), + index = integer(0), value = numeric(0), obj = c(1, 2)) > clp_objective(model) [1] 1 2 > clp_set_objective(model, c(3, 4)) > clp_objective(model) [1] 3 4 > clp_free(model) > > > > cleanEx() > nameEx("clp_objective_value") > ### * clp_objective_value > > flush(stderr()); flush(stdout()) > > ### Name: clp_objective_value > ### Title: Objective value and offset > ### Aliases: clp_objective_value clp_objective_offset > ### clp_set_objective_offset > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, obj = -1, rowub = 2) > clp_initial_solve(model) [1] 0 > clp_objective_value(model) [1] -2 > clp_free(model) > > > > cleanEx() > nameEx("clp_optimization_direction") > ### * clp_optimization_direction > > flush(stderr()); flush(stdout()) > > ### Name: clp_optimization_direction > ### Title: Optimization direction > ### Aliases: clp_optimization_direction clp_set_optimization_direction > ### clp_obj_sense clp_set_obj_sense > > ### ** Examples > > model <- clp_model() > clp_set_optimization_direction(model, -1) > clp_optimization_direction(model) [1] -1 > clp_free(model) > > > > cleanEx() > nameEx("clp_options") > ### * clp_options > > flush(stderr()); flush(stdout()) > > ### Name: clp_options > ### Title: Options for Clp's presolve and algorithm choice > ### Aliases: clp_options > > ### ** Examples > > opts <- clp_options() > clp_options_set_solve_type(opts, 1L) # primal simplex > clp_options_get_solve_type(opts) [1] 1 > > > > cleanEx() > nameEx("clp_options_do_dual") > ### * clp_options_do_dual > > flush(stderr()); flush(stdout()) > > ### Name: clp_options_do_dual > ### Title: Individual presolve transformations > ### Aliases: clp_options_do_dual clp_options_set_do_dual > ### clp_options_do_singleton clp_options_set_do_singleton > ### clp_options_do_doubleton clp_options_set_do_doubleton > ### clp_options_do_tripleton clp_options_set_do_tripleton > ### clp_options_do_tighten clp_options_set_do_tighten > ### clp_options_do_forcing clp_options_set_do_forcing > ### clp_options_do_implied_free clp_options_set_do_implied_free > ### clp_options_do_dupcol clp_options_set_do_dupcol clp_options_do_duprow > ### clp_options_set_do_duprow clp_options_do_singleton_column > ### clp_options_set_do_singleton_column clp_options_presolve_actions > ### clp_options_set_presolve_actions clp_options_substitution > ### clp_options_set_substitution clp_options_infeasible_return > ### clp_options_set_infeasible_return > > ### ** Examples > > opts <- clp_options() > clp_options_set_do_dual(opts, 1L) > clp_options_do_dual(opts) [1] 1 > clp_options_free(opts) > > > > cleanEx() > nameEx("clp_options_free") > ### * clp_options_free > > flush(stderr()); flush(stdout()) > > ### Name: clp_options_free > ### Title: Release a Clp options object > ### Aliases: clp_options_free > > ### ** Examples > > opts <- clp_options() > clp_options_free(opts) > > > > cleanEx() > nameEx("clp_options_set_solve_type") > ### * clp_options_set_solve_type > > flush(stderr()); flush(stdout()) > > ### Name: clp_options_set_solve_type > ### Title: Presolve and algorithm options > ### Aliases: clp_options_set_solve_type clp_options_get_solve_type > ### clp_options_set_presolve_type clp_options_get_presolve_type > ### clp_options_get_presolve_passes clp_options_set_special_option > ### clp_options_get_special_option clp_options_get_extra_info > > ### ** Examples > > opts <- clp_options() > clp_options_set_solve_type(opts, 0L) # dual simplex > clp_options_set_presolve_type(opts, 1L) # presolve off > clp_options_get_solve_type(opts) [1] 0 > clp_options_free(opts) > > > > cleanEx() > nameEx("clp_primal_tolerance") > ### * clp_primal_tolerance > > flush(stderr()); flush(stdout()) > > ### Name: clp_primal_tolerance > ### Title: Numerical tolerances and limits > ### Aliases: clp_primal_tolerance clp_set_primal_tolerance > ### clp_dual_tolerance clp_set_dual_tolerance clp_dual_objective_limit > ### clp_set_dual_objective_limit clp_dual_bound clp_set_dual_bound > ### clp_infeasibility_cost clp_set_infeasibility_cost clp_max_seconds > ### clp_set_max_seconds clp_max_iterations clp_set_max_iterations > ### clp_hit_max_iterations clp_small_element_value > ### clp_set_small_element_value > > ### ** Examples > > model <- clp_model() > clp_set_primal_tolerance(model, 1e-8) > clp_primal_tolerance(model) [1] 1e-08 > clp_set_max_iterations(model, 1000L) > clp_max_iterations(model) [1] 1000 > clp_free(model) > > > > cleanEx() > nameEx("clp_print_model") > ### * clp_print_model > > flush(stderr()); flush(stdout()) > > ### Name: clp_print_model > ### Title: Print a model through Clp > ### Aliases: clp_print_model > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, rowub = 1) > clp_print_model(model) clp numcols = 1, numrows = 1, numelem = 1 clp model = 0x979bf30, start = 0x995bd10, index = 0x995bd60, value = 0x94bc9c0 Dumping matrix... colordered: 1 major: 1 minor: 1 vec 0 has length 1 with entries: 0 1.0000000000000000000000000 Finished dumping matrix clp start[0] = 0 clp start[1] = 1 clp index[0] = 0, value[0] = 1 clp collb = 0x94bc7c0, colub = 0x995bb80, obj = 0x995bb30, rowlb = 0x995ba90, rowub = 0x94bc700 clp optimization direction = 1 (1 - minimize, -1 - maximize, 0 - ignore) clp collb[0] = 0, colub[0] = 1.79769e+308, obj[0] = 0 clp rowlb[0] = -1.79769e+308, rowub[0] = 1 > clp_free(model) > > > > cleanEx() > nameEx("clp_problem_name") > ### * clp_problem_name > > flush(stderr()); flush(stdout()) > > ### Name: clp_problem_name > ### Title: The name of the problem > ### Aliases: clp_problem_name clp_set_problem_name > > ### ** Examples > > model <- clp_model() > clp_set_problem_name(model, "transport") > clp_problem_name(model) [1] "transport" > clp_free(model) > > > > cleanEx() > nameEx("clp_read_mps") > ### * clp_read_mps > > flush(stderr()); flush(stdout()) > > ### Name: clp_read_mps > ### Title: Read an MPS file > ### Aliases: clp_read_mps > > ### ** Examples > > model <- clp_model() > path <- system.file("extdata", "productmix.mps", package = "coinclp") > if (nzchar(path)) { + clp_read_mps(model, path) + clp_num_rows(model) + } [1] 3 > clp_free(model) > > > > cleanEx() > nameEx("clp_resize") > ### * clp_resize > > flush(stderr()); flush(stdout()) > > ### Name: clp_resize > ### Title: Change the size of a model > ### Aliases: clp_resize > > ### ** Examples > > model <- clp_model() > clp_resize(model, 2, 3) > clp_num_cols(model) [1] 3 > clp_free(model) > > > > cleanEx() > nameEx("clp_row_names") > ### * clp_row_names > > flush(stderr()); flush(stdout()) > > ### Name: clp_row_names > ### Title: Row and column names > ### Aliases: clp_row_names clp_col_names clp_row_name clp_col_name > ### clp_set_names clp_set_row_name clp_set_col_name clp_drop_names > ### clp_length_names > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 1, c(0L, 1L, 2L), c(0L, 0L), c(1, 1), rowub = 1) > clp_set_names(model, "supply", c("x", "y")) > clp_col_names(model) [1] "x" "y" > clp_free(model) > > > > cleanEx() > nameEx("clp_save_model") > ### * clp_save_model > > flush(stderr()); flush(stdout()) > > ### Name: clp_save_model > ### Title: Save and restore a model > ### Aliases: clp_save_model clp_restore_model > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, obj = 1, rowub = 2) > path <- tempfile() > clp_save_model(model, path) ==4094804== Syscall param write(buf) points to uninitialised byte(s) ==4094804== at 0x5746F7D: write (/usr/src/debug/glibc-2.43-8.fc44.x86_64/io/../sysdeps/unix/sysv/linux/write.c:26) ==4094804== by 0x56C7E3C: _IO_file_write@@GLIBC_2.2.5 (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/fileops.c:1241) ==4094804== by 0x56C5BB5: new_do_write (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/fileops.c:483) ==4094804== by 0x56C6D10: _IO_do_write@@GLIBC_2.2.5 (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/fileops.c:460) ==4094804== by 0x56C63EF: _IO_file_close_it@@GLIBC_2.2.5 (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/fileops.c:136) ==4094804== by 0x56B9224: fclose@@GLIBC_2.2.5 (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/iofclose.c:53) ==4094804== by 0x1154ED21: ClpSimplex::saveModel(char const*) (/usr/src/debug/coin-or-Clp-1.17.10-11.fc44.x86_64/Clp/src/ClpSimplex.cpp:6994) ==4094804== by 0xBF0A8B3: coinclp_save_model (/data/localhost/ripley/R/packages/tests-vg/coinclp/src/coinclp_io.cpp:201) ==4094804== by 0x496E69: R_doDotCall (/data/localhost/ripley/R/svn/R-devel/src/main/dotcode.c:757) ==4094804== by 0x4D4C9A: bcEval_loop (/data/localhost/ripley/R/svn/R-devel/src/main/eval.c:8704) ==4094804== Address 0x9e6223c is 204 bytes inside a block of size 4,096 alloc'd ==4094804== at 0x4841AE6: malloc (/builddir/build/BUILD/valgrind-3.27.1-build/valgrind-3.27.1/coregrind/m_replacemalloc/vg_replace_malloc.c:447) ==4094804== by 0x56B8F42: _IO_file_doallocate (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/filedoalloc.c:91) ==4094804== by 0x56C94B5: _IO_doallocbuf (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/genops.c:373) ==4094804== by 0x56C94B5: _IO_doallocbuf (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/genops.c:368) ==4094804== by 0x56C72B8: _IO_file_overflow@@GLIBC_2.2.5 (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/fileops.c:779) ==4094804== by 0x56C7F87: _IO_new_file_xsputn (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/fileops.c:1305) ==4094804== by 0x56C7F87: _IO_file_xsputn@@GLIBC_2.2.5 (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/fileops.c:1258) ==4094804== by 0x56BA7DA: fwrite (/usr/src/debug/glibc-2.43-8.fc44.x86_64/libio/iofwrite.c:44) ==4094804== by 0x1154E8CF: ClpSimplex::saveModel(char const*) (/usr/src/debug/coin-or-Clp-1.17.10-11.fc44.x86_64/Clp/src/ClpSimplex.cpp:6860) ==4094804== by 0xBF0A8B3: coinclp_save_model (/data/localhost/ripley/R/packages/tests-vg/coinclp/src/coinclp_io.cpp:201) ==4094804== by 0x496E69: R_doDotCall (/data/localhost/ripley/R/svn/R-devel/src/main/dotcode.c:757) ==4094804== by 0x4D4C9A: bcEval_loop (/data/localhost/ripley/R/svn/R-devel/src/main/eval.c:8704) ==4094804== by 0x4E4141: bcEval (/data/localhost/ripley/R/svn/R-devel/src/main/eval.c:7533) ==4094804== by 0x4E4141: bcEval (/data/localhost/ripley/R/svn/R-devel/src/main/eval.c:7518) ==4094804== by 0x4E450A: Rf_eval (/data/localhost/ripley/R/svn/R-devel/src/main/eval.c:1167) ==4094804== Uninitialised value was created by a stack allocation ==4094804== at 0xBF09470: ??? (in /data/localhost/ripley/R/packages/tests-vg/coinclp.Rcheck/coinclp/libs/coinclp.so) ==4094804== > clp_restore_model(model, path) > clp_free(model) > unlink(path) > > > > cleanEx() > nameEx("clp_set_integer") > ### * clp_set_integer > > flush(stderr()); flush(stdout()) > > ### Name: clp_set_integer > ### Title: Mark columns as integer > ### Aliases: clp_set_integer clp_delete_integer clp_integer_information > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 0, c(0L, 0L, 0L), integer(0), numeric(0)) > clp_set_integer(model, c(TRUE, FALSE)) > clp_integer_information(model) [1] TRUE FALSE > clp_free(model) > > > > cleanEx() > nameEx("clp_solve") > ### * clp_solve > > flush(stderr()); flush(stdout()) > > ### Name: clp_solve > ### Title: Solve a linear program > ### Aliases: clp_solve > > ### ** Examples > > # maximise 143x + 60y subject to > # 120x + 210y <= 15000 > # 110x + 30y <= 4000 > # x + y <= 75 > A <- rbind(c(120, 210), c(110, 30), c(1, 1)) > res <- clp_solve(c(143, 60), A, "<=", c(15000, 4000, 75), max = TRUE) > res$objval [1] 6315.625 > res$solution [1] 21.875 53.125 > > > > cleanEx() > nameEx("clp_status") > ### * clp_status > > flush(stderr()); flush(stdout()) > > ### Name: clp_status > ### Title: Solution status > ### Aliases: clp_status clp_set_status clp_secondary_status > ### clp_set_secondary_status clp_status_message > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, obj = 1, rowlb = 1) > clp_initial_solve(model) [1] 0 > clp_status_message(clp_status(model)) [1] "optimal" > clp_free(model) > > > > cleanEx() > nameEx("clp_status_exists") > ### * clp_status_exists > > flush(stderr()); flush(stdout()) > > ### Name: clp_status_exists > ### Title: Basis status for warm starts > ### Aliases: clp_status_exists clp_status_array clp_copyin_status > ### clp_row_status clp_col_status clp_set_row_status clp_set_col_status > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 1, c(0L, 1L, 2L), c(0L, 0L), c(1, 1), + obj = c(-1, -1), rowub = 1) > clp_initial_solve(model) [1] 0 > basis <- clp_status_array(model) > clp_copyin_status(model, basis) > clp_free(model) > > > > cleanEx() > nameEx("clp_sum_primal_infeasibilities") > ### * clp_sum_primal_infeasibilities > > flush(stderr()); flush(stdout()) > > ### Name: clp_sum_primal_infeasibilities > ### Title: Infeasibility measures > ### Aliases: clp_sum_primal_infeasibilities clp_sum_dual_infeasibilities > ### clp_num_primal_infeasibilities clp_num_dual_infeasibilities > ### clp_check_solution > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, obj = 1, rowlb = 1) > clp_initial_solve(model) [1] 0 > clp_sum_primal_infeasibilities(model) [1] 0 > clp_free(model) > > > > cleanEx() > nameEx("clp_unbounded_ray") > ### * clp_unbounded_ray > > flush(stderr()); flush(stdout()) > > ### Name: clp_unbounded_ray > ### Title: Rays certifying unboundedness or infeasibility > ### Aliases: clp_unbounded_ray clp_infeasibility_ray > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 1, 1, c(0L, 1L), 0L, 1, obj = -1, rowub = clp_inf()) > clp_initial_solve(model) [1] 2 > clp_unbounded_ray(model) [1] 1e+10 > clp_free(model) > > > > cleanEx() > nameEx("clp_version") > ### * clp_version > > flush(stderr()); flush(stdout()) > > ### Name: clp_version > ### Title: Version of the Clp library in use > ### Aliases: clp_version clp_features > > ### ** Examples > > clp_version() $version [1] "1.17.10" $major [1] 1 $minor [1] 17 $release [1] 10 > clp_features() write_mps modify_coefficient set_names maximum_iterations TRUE TRUE TRUE TRUE > > > > cleanEx() > nameEx("clp_write_mps") > ### * clp_write_mps > > flush(stderr()); flush(stdout()) > > ### Name: clp_write_mps > ### Title: Write an MPS file > ### Aliases: clp_write_mps > > ### ** Examples > > model <- clp_model() > clp_load_problem(model, 2, 1, c(0L, 1L, 2L), c(0L, 0L), c(1, 1), + obj = c(1, 2), rowub = 4) > path <- tempfile(fileext = ".mps") > clp_write_mps(model, path) > readLines(path)[1:3] [1] "NAME ClpDefau" "ROWS" " N OBJROW" > clp_free(model) > unlink(path) > > > > cleanEx() > nameEx("copyNamesCLP") > ### * copyNamesCLP > > flush(stderr()); flush(stdout()) > > ### Name: copyNamesCLP > ### Title: Names and files, clpAPI style > ### Aliases: copyNamesCLP dropNamesCLP lengthNamesCLP probNameCLP > ### setRowNameCLP setColNameCLP printModelCLP readMPSCLP writeMPSCLP > ### saveModelCLP restoreModelCLP modifyCoefficientCLP isAvailableFuncCLP > > ### ** Examples > > lp <- initProbCLP() > loadMatrixCLP(lp, 2, 1, c(0, 1, 2), c(0, 0), c(1, 1)) > copyNamesCLP(lp, c("x", "y"), "budget") > lengthNamesCLP(lp) [1] 6 > delProbCLP(lp) > > > > cleanEx() > nameEx("getNumRowsCLP") > ### * getNumRowsCLP > > flush(stderr()); flush(stdout()) > > ### Name: getNumRowsCLP > ### Title: Problem data, clpAPI style > ### Aliases: getNumRowsCLP getNumColsCLP getNumNnzCLP getObjCoefsCLP > ### chgObjCoefsCLP getColLowerCLP chgColLowerCLP getColUpperCLP > ### chgColUpperCLP getRowLowerCLP chgRowLowerCLP getRowUpperCLP > ### chgRowUpperCLP getVecStartCLP getVecLenCLP getIndCLP getNnzCLP > > ### ** Examples > > lp <- initProbCLP() > loadMatrixCLP(lp, 2, 0, c(0, 0, 0), integer(0), numeric(0)) > chgObjCoefsCLP(lp, c(1, 2)) > getObjCoefsCLP(lp) [1] 1 2 > delProbCLP(lp) > > > > cleanEx() > nameEx("getSolStatusCLP") > ### * getSolStatusCLP > > flush(stderr()); flush(stdout()) > > ### Name: getSolStatusCLP > ### Title: Solutions and status, clpAPI style > ### Aliases: getSolStatusCLP getObjValCLP getColPrimCLP getColDualCLP > ### getRowPrimCLP getRowDualCLP status_codeCLP return_codeCLP > > ### ** Examples > > lp <- initProbCLP() > loadProblemCLP(lp, 1, 1, c(0, 1), 0, 1, obj_coef = -1, rlb = -1e30, rub = 2) > setLogLevelCLP(lp, 0) > solveInitialCLP(lp) [1] 0 > status_codeCLP(getSolStatusCLP(lp)) [1] "solution is optimal" > delProbCLP(lp) > > > > cleanEx() > nameEx("initProbCLP") > ### * initProbCLP > > flush(stderr()); flush(stdout()) > > ### Name: initProbCLP > ### Title: Create and delete a problem, clpAPI style > ### Aliases: initProbCLP delProbCLP > > ### ** Examples > > lp <- initProbCLP() > setLogLevelCLP(lp, 0) > delProbCLP(lp) > > > > cleanEx() > nameEx("loadProblemCLP") > ### * loadProblemCLP > > flush(stderr()); flush(stdout()) > > ### Name: loadProblemCLP > ### Title: Build a problem, clpAPI style > ### Aliases: loadProblemCLP loadMatrixCLP > > ### ** Examples > > lp <- initProbCLP() > loadProblemCLP(lp, 2, 1, c(0, 1, 2), c(0, 0), c(1, 1), + lb = c(0, 0), ub = c(1e30, 1e30), obj_coef = c(-1, -2), + rlb = -1e30, rub = 3) > solveInitialCLP(lp) [1] 0 > getObjValCLP(lp) [1] -6 > delProbCLP(lp) > > > > cleanEx() > nameEx("resizeCLP") > ### * resizeCLP > > flush(stderr()); flush(stdout()) > > ### Name: resizeCLP > ### Title: Change the size of a problem, clpAPI style > ### Aliases: resizeCLP > > ### ** Examples > > lp <- initProbCLP() > resizeCLP(lp, 2, 2) > getNumRowsCLP(lp) [1] 2 > delProbCLP(lp) > > > > cleanEx() > nameEx("setObjDirCLP") > ### * setObjDirCLP > > flush(stderr()); flush(stdout()) > > ### Name: setObjDirCLP > ### Title: Solver settings, clpAPI style > ### Aliases: setObjDirCLP getObjDirCLP setLogLevelCLP getLogLevelCLP > ### scaleModelCLP getScaleFlagCLP setNumberIterationsCLP > ### setMaximumIterationsCLP getMaximumIterationsCLP > ### getHitMaximumIterationsCLP setMaximumSecondsCLP getMaximumSecondsCLP > > ### ** Examples > > lp <- initProbCLP() > setObjDirCLP(lp, -1) > getObjDirCLP(lp) [1] -1 > delProbCLP(lp) > > > > cleanEx() > nameEx("solveInitialCLP") > ### * solveInitialCLP > > flush(stderr()); flush(stdout()) > > ### Name: solveInitialCLP > ### Title: Solve a problem, clpAPI style > ### Aliases: solveInitialCLP solveInitialDualCLP solveInitialPrimalCLP > ### solveInitialBarrierCLP solveInitialBarrierNoCrossCLP primalCLP > ### dualCLP idiotCLP > > ### ** Examples > > lp <- initProbCLP() > loadProblemCLP(lp, 1, 1, c(0, 1), 0, 1, obj_coef = -1, rlb = -1e30, rub = 2) > setLogLevelCLP(lp, 0) > solveInitialCLP(lp) [1] 0 > getColPrimCLP(lp) [1] 2 > delProbCLP(lp) > > > > cleanEx() > nameEx("versionCLP") > ### * versionCLP > > flush(stderr()); flush(stdout()) > > ### Name: versionCLP > ### Title: The Clp version, clpAPI style > ### Aliases: versionCLP > > ### ** Examples > > versionCLP() [1] "1.17.10" > > > > ### *