initial commit of version 1.2.11

DESCRIPTION

+Package: cplexAPI
+Type: Package
+Title: R Interface to C API of IBM ILOG CPLEX
+Version: 1.2.11
+Date: 2014-07-28
+Authors@R: c(person("Gabriel", "Gelius-Dietrich", role = c("aut", "cre"), email = "geliudie@uni-duesseldorf.de"))
+Depends: R (>= 2.6.0)
+Imports: methods
+Description: R Interface to C API of IBM ILOG CPLEX, depends on IBM ILOG CPLEX (>= 12.1)
+SystemRequirements: IBM ILOG CPLEX (>= 12.1)
+License: GPL-3
+LazyLoad: yes
+Collate: generics.R cplexConst.R cplexErrorClass.R cplexPtrClass.R
+        cplex.R cplexAPI.R cplex_checkAPI.R cplex_longparamAPI.R zzz.R
+Packaged: 2014-07-28 08:53:41 UTC; gabriel
+Author: Gabriel Gelius-Dietrich [aut, cre]
+Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+NeedsCompilation: yes
+Repository: CRAN
+Date/Publication: 2014-07-28 18:16:22

NAMESPACE

+useDynLib(cplexAPI)
+
+import(methods)
+
+exportClass("cplexPtr")
+exportClass("cplexError")
+
+export(
+## methods
+"err",
+"errmsg",
+"errnum",
+"errnum<-",
+"cplexPointer",
+"cplexPtrType",
+"cplexPtrType<-",
+"isCPLEXprobPointer",
+"isCPLEXenvPointer",
+"isCPLEXfilePointer",
+"isCPLEXchanPointer",
+"isCPLEXtermPointer",
+"isNULLpointerCPLEX",
+"summary",
+## function names
+addChannelCPLEX,
+addColsCPLEX,
+addFpDestCPLEX,
+addIndConstrCPLEX,
+addMIPstartsCPLEX,
+addRowsCPLEX,
+addQConstrCPLEX,
+baroptCPLEX,
+baseWriteCPLEX,
+basicPresolveCPLEX,
+boundSaCPLEX,
+chgBndsCPLEX,
+chgCoefCPLEX,
+chgCoefListCPLEX,
+chgColNameCPLEX,
+chgColsBndsCPLEX,
+chgColTypeCPLEX,
+chgMIPstartsCPLEX,
+chgNameCPLEX,
+chgObjCPLEX,
+chgProbNameCPLEX,
+chgProbTypeCPLEX,
+chgQPcoefCPLEX,
+chgRhsCPLEX,
+chgRngValCPLEX,
+chgRowNameCPLEX,
+chgSenseCPLEX,
+chgTerminateCPLEX,
+cleanupCoefCPLEX,
+cloneProbCPLEX,
+closeEnvCPLEX,
+closeFileCPLEX,
+closeProbCPLEX,
+cLpWriteCPLEX,
+completelpCPLEX,
+copyBaseCPLEX,
+copyColTypeCPLEX,
+copyLpCPLEX,
+copyLpwNamesCPLEX,
+copyObjNameCPLEX,
+copyOrderCPLEX,
+copyPartBaseCPLEX,
+copyQPsepCPLEX,
+copyQuadCPLEX,
+copyStartCPLEX,
+delChannelCPLEX,
+delColsCPLEX,
+delFpDestCPLEX,
+delIndConstrsCPLEX,
+delMIPstartsCPLEX,
+delNamesCPLEX,
+delProbCPLEX,
+delQConstrsCPLEX,
+delRowsCPLEX,
+delSetColsCPLEX,
+delSetRowsCPLEX,
+delTerminateCPLEX,
+disconnectChannelCPLEX,
+dualoptCPLEX,
+dualWriteCPLEX,
+feasOptCPLEX,
+fileputCPLEX,
+flushChannelCPLEX,
+flushStdChannelsCPLEX,
+freePresolveCPLEX,
+getBaseCPLEX,
+getBestObjValCPLEX,
+getChannelsCPLEX,
+getChgParmCPLEX,
+getCoefCPLEX,
+getColIndexCPLEX,
+getColInfeasCPLEX,
+getColNameCPLEX,
+getColsCPLEX,
+getColTypeCPLEX,
+getConflictCPLEX,
+getConflictExtCPLEX,
+getCutoffCPLEX,
+getDblParmCPLEX,
+getDblQualCPLEX,
+getDbsCntCPLEX,
+getDjCPLEX,
+getErrorStrCPLEX,
+getGradCPLEX,
+getIndConstrCPLEX,
+getInfoDblParmCPLEX,
+getInfoIntParmCPLEX,
+getInfoLongParmCPLEX,
+getInfoStrParmCPLEX,
+getIntParmCPLEX,
+getIntQualCPLEX,
+getItCntCPLEX,
+getLogFileCPLEX,
+getLongParmCPLEX,
+getLowBndsIdsCPLEX,
+getLowerBndsCPLEX,
+getMethodCPLEX,
+getMIPrelGapCPLEX,
+getMIPstartIndexCPLEX,
+getMIPstartNameCPLEX,
+getMIPstartsCPLEX,
+getNumColsCPLEX,
+getNumMIPstartsCPLEX,
+getNumNnzCPLEX,
+getNumQuadCPLEX,
+getOrderCPLEX,
+getQConstrCPLEX,
+getQPcoefCPLEX,
+getNumQPnzCPLEX,
+getNumRowsCPLEX,
+getObjCPLEX,
+getObjDirCPLEX,
+getObjNameCPLEX,
+getObjOffsetCPLEX,
+getObjValCPLEX,
+getParmNameCPLEX,
+getParmNumCPLEX,
+getParmTypeCPLEX,
+getParmValCPLEX,
+getPhase1CntCPLEX,
+getPiCPLEX,
+getPreStatCPLEX,
+getProbNameCPLEX,
+getProbTypeCPLEX,
+getProbVarCPLEX,
+getQuadCPLEX,
+getRedLpCPLEX,
+getRhsCPLEX,
+getRngValCPLEX,
+getRowIndexCPLEX,
+getRowInfeasCPLEX,
+getRowNameCPLEX,
+getRowsCPLEX,
+getSenseCPLEX,
+getSiftItCntCPLEX,
+getSiftPase1CntCPLEX,
+getSlackCPLEX,
+getStatCPLEX,
+getStatStrCPLEX,
+getStrParmCPLEX,
+getSubMethodCPLEX,
+getSubStatCPLEX,
+getTimeCPLEX,
+getUppBndsIdsCPLEX,
+getUpperBndsCPLEX,
+getVersionCPLEX,
+hybbaroptCPLEX,
+hybnetoptCPLEX,
+initProbCPLEX,
+lpoptCPLEX,
+mipoptCPLEX,
+newColsCPLEX,
+newRowsCPLEX,
+objSaCPLEX,
+openEnvCPLEX,
+openFileCPLEX,
+openProbCPLEX,
+ordWriteCPLEX,
+preslvWriteCPLEX,
+presolveCPLEX,
+primoptCPLEX,
+printTerminateCPLEX,
+qpoptCPLEX,
+readCopyBaseCPLEX,
+readCopyMIPstartsCPLEX,
+readCopyOrderCPLEX,
+readCopyParmCPLEX,
+readCopyProbCPLEX,
+readCopySolCPLEX,
+refineConflictCPLEX,
+refineConflictExtCPLEX,
+refineMIPstartConflictCPLEX,
+refineMIPstartConflictExtCPLEX,
+return_codeCPLEX,
+rhsSaCPLEX,
+setDblParmCPLEX,
+setDefaultParmCPLEX,
+setIntParmCPLEX,
+setLogFileCPLEX,
+setLongParmCPLEX,
+setObjDirCPLEX,
+setStrParmCPLEX,
+setTerminateCPLEX,
+siftoptCPLEX,
+solnInfoCPLEX,
+solutionCPLEX,
+solWriteCPLEX,
+status_codeCPLEX,
+tightenBndsCPLEX,
+tuneParmCPLEX,
+unscaleProbCPLEX,
+writeMIPstartsCPLEX,
+writeParmCPLEX,
+writeProbCPLEX,
+## check function names
+checkAddColsCPLEX,
+checkAddRowsCPLEX,
+checkChgCoefListCPLEX,
+checkCopyColTypeCPLEX,
+checkCopyLpCPLEX,
+checkCopyLpwNamesCPLEX,
+checkCopyQPsepCPLEX,
+checkCopyQuadCPLEX,
+checkValsCPLEX,
+## parameter variable names
+CPX_ALG_AUTOMATIC,
+CPX_ALG_BAROPT,
+CPX_ALG_BARRIER,
+CPX_ALG_CONCURRENT,
+CPX_ALG_DUAL,
+CPX_ALG_FEASOPT,
+CPX_ALG_MIP,
+CPX_ALG_NET,
+CPX_ALG_NONE,
+CPX_ALG_PIVOT,
+CPX_ALG_PIVOTIN,
+CPX_ALG_PIVOTOUT,
+CPX_ALG_PRIMAL,
+CPX_ALG_ROBUST,
+CPX_ALG_SIFTING,
+CPX_AT_LOWER,
+CPX_AT_UPPER,
+CPX_BARORDER_AMD,
+CPX_BARORDER_AMF,
+CPX_BARORDER_AUTO,
+CPX_BARORDER_ND,
+CPX_BASIC_SOLN,
+CPX_BASIC,
+CPX_BINARY,
+CPX_BRANCH_DOWN,
+CPX_BRANCH_GLOBAL,
+CPX_BRANCH_UP,
+CPX_BRDIR_AUTO,
+CPX_BRDIR_DOWN,
+CPX_BRDIR_UP,
+CPX_CON_ABS,
+CPX_CON_DISJCST,
+CPX_CON_INDDISJCST,
+CPX_CON_INDICATOR,
+CPX_CON_LAST_CONTYPE,
+CPX_CON_LINEAR,
+CPX_CON_LOWER_BOUND,
+CPX_CON_MAXEXPR,
+CPX_CON_MINEXPR,
+CPX_CON_PWL,
+CPX_CON_QUADRATIC,
+CPX_CON_SETVAR,
+CPX_CON_SETVARCARD,
+CPX_CON_SETVARDOMAIN,
+CPX_CON_SETVAREQ,
+CPX_CON_SETVARINTERSECT,
+CPX_CON_SETVARINTERSECTION,
+CPX_CON_SETVARMAX,
+CPX_CON_SETVARMEMBER,
+CPX_CON_SETVARMIN,
+CPX_CON_SETVARNEQ,
+CPX_CON_SETVARNEQCST,
+CPX_CON_SETVARNULLINTERSECT,
+CPX_CON_SETVARSUBSET,
+CPX_CON_SETVARSUM,
+CPX_CON_SETVARUNION,
+CPX_CON_SOS,
+CPX_CON_UPPER_BOUND,
+CPX_CONFLICT_EXCLUDED,
+CPX_CONFLICT_LB,
+CPX_CONFLICT_MEMBER,
+CPX_CONFLICT_POSSIBLE_LB,
+CPX_CONFLICT_POSSIBLE_MEMBER,
+CPX_CONFLICT_POSSIBLE_UB,
+CPX_CONFLICT_UB,
+CPX_CONTINUOUS,
+CPX_DPRIIND_AUTO,
+CPX_DPRIIND_DEVEX,
+CPX_DPRIIND_FULL_STEEP,
+CPX_DPRIIND_FULL,
+CPX_DPRIIND_STEEP,
+CPX_DPRIIND_STEEPQSTART,
+CPX_DUAL_OBJ,
+CPX_EXACT_KAPPA,
+CPX_FEASOPT_MIN_INF,
+CPX_FEASOPT_MIN_QUAD,
+CPX_FEASOPT_MIN_SUM,
+CPX_FEASOPT_OPT_INF,
+CPX_FEASOPT_OPT_QUAD,
+CPX_FEASOPT_OPT_SUM,
+CPX_FREE_SUPER,
+CPX_IMPLIED_INTEGER_FEASIBLE,
+CPX_INFBOUND,
+CPX_INTEGER_FEASIBLE,
+CPX_INTEGER_INFEASIBLE,
+CPX_INTEGER,
+CPX_KAPPA_ATTENTION,
+CPX_KAPPA_ILLPOSED,
+CPX_KAPPA_MAX,
+CPX_KAPPA_STABLE,
+CPX_KAPPA_SUSPICIOUS,
+CPX_KAPPA_UNSTABLE,
+CPX_KAPPA,
+CPX_MAX_COMP_SLACK,
+CPX_MAX_DUAL_INFEAS,
+CPX_MAX_DUAL_RESIDUAL,
+CPX_MAX_INDSLACK_INFEAS,
+CPX_MAX_INT_INFEAS,
+CPX_MAX_PI,
+CPX_MAX_PRIMAL_INFEAS,
+CPX_MAX_PRIMAL_RESIDUAL,
+CPX_MAX_QCPRIMAL_RESIDUAL,
+CPX_MAX_QCSLACK_INFEAS,
+CPX_MAX_QCSLACK,
+CPX_MAX_RED_COST,
+CPX_MAX_SCALED_DUAL_INFEAS,
+CPX_MAX_SCALED_DUAL_RESIDUAL,
+CPX_MAX_SCALED_PI,
+CPX_MAX_SCALED_PRIMAL_INFEAS,
+CPX_MAX_SCALED_PRIMAL_RESIDUAL,
+CPX_MAX_SCALED_RED_COST,
+CPX_MAX_SCALED_SLACK,
+CPX_MAX_SCALED_X,
+CPX_MAX_SLACK,
+CPX_MAX_X,
+CPX_MAX,
+CPX_MIN,
+CPX_MIPEMPHASIS_BALANCED,
+CPX_MIPEMPHASIS_BESTBOUND,
+CPX_MIPEMPHASIS_FEASIBILITY,
+CPX_MIPEMPHASIS_HIDDENFEAS,
+CPX_MIPEMPHASIS_OPTIMALITY,
+CPX_MIPKAPPA_AUTO,
+CPX_MIPKAPPA_FULL,
+CPX_MIPKAPPA_OFF,
+CPX_MIPKAPPA_SAMPLE,
+CPX_MIPORDER_BOUNDS,
+CPX_MIPORDER_COST,
+CPX_MIPORDER_SCALEDCOST,
+CPX_MIPSEARCH_AUTO,
+CPX_MIPSEARCH_DYNAMIC,
+CPX_MIPSEARCH_TRADITIONAL,
+CPX_MIPSTART_AUTO,
+CPX_MIPSTART_CHECKFEAS,
+CPX_MIPSTART_REPAIR,
+CPX_MIPSTART_SOLVEFIXED,
+CPX_MIPSTART_SOLVEMIP,
+CPX_NO_SOLN,
+CPX_NODESEL_BESTBOUND,
+CPX_NODESEL_BESTEST_ALT,
+CPX_NODESEL_BESTEST,
+CPX_NODESEL_DFS,
+CPX_NONBASIC_SOLN,
+CPX_OBJ_GAP,
+CPX_OFF,
+CPX_ON,
+CPX_PARALLEL_AUTO,
+CPX_PARALLEL_DETERMINISTIC,
+CPX_PARALLEL_OPPORTUNISTIC,
+CPX_PARAM_ADVIND,
+CPX_PARAM_AGGCUTLIM,
+CPX_PARAM_AGGFILL,
+CPX_PARAM_AGGIND,
+CPX_PARAM_ALL_MAX,
+CPX_PARAM_ALL_MIN,
+CPX_PARAM_APIENCODING,
+CPX_PARAM_AUXROOTTHREADS,
+CPX_PARAM_BARALG,
+CPX_PARAM_BARCOLNZ,
+CPX_PARAM_BARCROSSALG,
+CPX_PARAM_BARDISPLAY,
+CPX_PARAM_BARDSTART,
+CPX_PARAM_BAREPCOMP,
+CPX_PARAM_BARGROWTH,
+CPX_PARAM_BARITLIM,
+CPX_PARAM_BARMAXCOR,
+CPX_PARAM_BAROBJRNG,
+CPX_PARAM_BARORDER,
+CPX_PARAM_BARPSTART,
+CPX_PARAM_BARQCPEPCOMP,
+CPX_PARAM_BARSTARTALG,
+CPX_PARAM_BASINTERVAL,
+CPX_PARAM_BBINTERVAL,
+CPX_PARAM_BNDSTRENIND,
+CPX_PARAM_BRDIR,
+CPX_PARAM_BTTOL,
+CPX_PARAM_CALCQCPDUALS,
+CPX_PARAM_CFILEMUL,
+CPX_PARAM_CLIQUES,
+CPX_PARAM_CLOCKTYPE,
+CPX_PARAM_CLONELOG,
+CPX_PARAM_COEREDIND,
+CPX_PARAM_COLREADLIM,
+CPX_PARAM_CONFLICTDISPLAY,
+CPX_PARAM_COVERS,
+CPX_PARAM_CRAIND,
+CPX_PARAM_CUTLO,
+CPX_PARAM_CUTPASS,
+CPX_PARAM_CUTSFACTOR,
+CPX_PARAM_CUTUP,
+CPX_PARAM_DATACHECK,
+CPX_PARAM_DEPIND,
+CPX_PARAM_DETTILIM,
+CPX_PARAM_DISJCUTS,
+CPX_PARAM_DIVETYPE,
+CPX_PARAM_DPRIIND,
+CPX_PARAM_EACHCUTLIM,
+CPX_PARAM_EPAGAP,
+CPX_PARAM_EPGAP,
+CPX_PARAM_EPINT,
+CPX_PARAM_EPLIN,
+CPX_PARAM_EPMRK,
+CPX_PARAM_EPOPT_H,
+CPX_PARAM_EPOPT,
+CPX_PARAM_EPPER,
+CPX_PARAM_EPRELAX,
+CPX_PARAM_EPRHS_H,
+CPX_PARAM_EPRHS,
+CPX_PARAM_FASTMIP,
+CPX_PARAM_FEASOPTMODE,
+CPX_PARAM_FILEENCODING,
+CPX_PARAM_FLOWCOVERS,
+CPX_PARAM_FLOWPATHS,
+CPX_PARAM_FPHEUR,
+CPX_PARAM_FRACCAND,
+CPX_PARAM_FRACCUTS,
+CPX_PARAM_FRACPASS,
+CPX_PARAM_GUBCOVERS,
+CPX_PARAM_HEURFREQ,
+CPX_PARAM_IMPLBD,
+CPX_PARAM_INTSOLFILEPREFIX,
+CPX_PARAM_INTSOLLIM,
+CPX_PARAM_ITLIM,
+CPX_PARAM_LANDPCUTS,
+CPX_PARAM_LBHEUR,
+CPX_PARAM_LPMETHOD,
+CPX_PARAM_MCFCUTS,
+CPX_PARAM_MEMORYEMPHASIS,
+CPX_PARAM_MIPCBREDLP,
+CPX_PARAM_MIPDISPLAY,
+CPX_PARAM_MIPEMPHASIS,
+CPX_PARAM_MIPINTERVAL,
+CPX_PARAM_MIPKAPPASTATS,
+CPX_PARAM_MIPORDIND,
+CPX_PARAM_MIPORDTYPE,
+CPX_PARAM_MIPSEARCH,
+CPX_PARAM_MIQCPSTRAT,
+CPX_PARAM_MIRCUTS,
+CPX_PARAM_MPSLONGNUM,
+CPX_PARAM_NETDISPLAY,
+CPX_PARAM_NETEPOPT,
+CPX_PARAM_NETEPRHS,
+CPX_PARAM_NETFIND,
+CPX_PARAM_NETITLIM,
+CPX_PARAM_NETPPRIIND,
+CPX_PARAM_NODEFILEIND,
+CPX_PARAM_NODELIM,
+CPX_PARAM_NODESEL,
+CPX_PARAM_NUMERICALEMPHASIS,
+CPX_PARAM_NZREADLIM,
+CPX_PARAM_OBJDIF,
+CPX_PARAM_OBJLLIM,
+CPX_PARAM_OBJULIM,
+CPX_PARAM_PARALLELMODE,
+CPX_PARAM_PERIND,
+CPX_PARAM_PERLIM,
+CPX_PARAM_POLISHAFTEREPAGAP,
+CPX_PARAM_POLISHAFTEREPGAP,
+CPX_PARAM_POLISHAFTERINTSOL,
+CPX_PARAM_POLISHAFTERNODE,
+CPX_PARAM_POLISHAFTERTIME,
+CPX_PARAM_POLISHTIME,
+CPX_PARAM_POPULATELIM,
+CPX_PARAM_PPRIIND,
+CPX_PARAM_PREDUAL,
+CPX_PARAM_PREIND,
+CPX_PARAM_PRELINEAR,
+CPX_PARAM_PREPASS,
+CPX_PARAM_PRESLVND,
+CPX_PARAM_PRICELIM,
+CPX_PARAM_PROBE,
+CPX_PARAM_PROBETIME,
+CPX_PARAM_QPMAKEPSDIND,
+CPX_PARAM_QPMETHOD,
+CPX_PARAM_QPNZREADLIM,
+CPX_PARAM_RAMPUPDETTILIM,
+CPX_PARAM_RAMPUPDURATION,
+CPX_PARAM_RAMPUPTILIM,
+CPX_PARAM_REDUCE,
+CPX_PARAM_REINV,
+CPX_PARAM_RELAXPREIND,
+CPX_PARAM_RELOBJDIF,
+CPX_PARAM_REPAIRTRIES,
+CPX_PARAM_REPEATPRESOLVE,
+CPX_PARAM_REVERSEIND,
+CPX_PARAM_RFILEMUL,
+CPX_PARAM_RINSHEUR,
+CPX_PARAM_ROWREADLIM,
+CPX_PARAM_SCAIND,
+CPX_PARAM_SCRIND,
+CPX_PARAM_SIFTALG,
+CPX_PARAM_SIFTDISPLAY,
+CPX_PARAM_SIFTITLIM,
+CPX_PARAM_SIMDISPLAY,
+CPX_PARAM_SINGLIM,
+CPX_PARAM_SINGTOL,
+CPX_PARAM_SOLNPOOLAGAP,
+CPX_PARAM_SOLNPOOLCAPACITY,
+CPX_PARAM_SOLNPOOLGAP,
+CPX_PARAM_SOLNPOOLINTENSITY,
+CPX_PARAM_SOLNPOOLREPLACE,
+CPX_PARAM_SOLUTIONTARGET,
+CPX_PARAM_STARTALG,
+CPX_PARAM_STRONGCANDLIM,
+CPX_PARAM_STRONGITLIM,
+CPX_PARAM_SUBALG,
+CPX_PARAM_SUBMIPNODELIM,
+CPX_PARAM_SYMMETRY,
+CPX_PARAM_THREADS,
+CPX_PARAM_TILIM,
+CPX_PARAM_TRELIM,
+CPX_PARAM_TUNINGDISPLAY,
+CPX_PARAM_TUNINGMEASURE,
+CPX_PARAM_TUNINGREPEAT,
+CPX_PARAM_TUNINGTILIM,
+CPX_PARAM_VARSEL,
+CPX_PARAM_WORKDIR,
+CPX_PARAM_WORKMEM,
+CPX_PARAM_WRITELEVEL,
+CPX_PARAM_XXXIND,
+CPX_PARAM_ZEROHALFCUTS,
+CPX_PARAMTYPE_DOUBLE,
+CPX_PARAMTYPE_INT,
+CPX_PARAMTYPE_LONG,
+CPX_PARAMTYPE_NONE,
+CPX_PARAMTYPE_STRING,
+CPX_PPRIIND_AUTO,
+CPX_PPRIIND_DEVEX,
+CPX_PPRIIND_FULL,
+CPX_PPRIIND_PARTIAL,
+CPX_PPRIIND_STEEP,
+CPX_PPRIIND_STEEPQSTART,
+CPX_PRECOL_AGG,
+CPX_PRECOL_FIX,
+CPX_PRECOL_LOW,
+CPX_PRECOL_OTHER,
+CPX_PRECOL_UP,
+CPX_PREREDUCE_DUALONLY,
+CPX_PREREDUCE_NOPRIMALORDUAL,
+CPX_PREREDUCE_PRIMALANDDUAL,
+CPX_PREREDUCE_PRIMALONLY,
+CPX_PREROW_AGG,
+CPX_PREROW_OTHER,
+CPX_PREROW_RED,
+CPX_PRIMAL_OBJ,
+CPX_PRIMAL_SOLN,
+CPX_SEMICONT,
+CPX_SEMIINT,
+CPX_SOLNPOOL_DIV,
+CPX_SOLNPOOL_FIFO,
+CPX_SOLNPOOL_FILTER_DIVERSITY,
+CPX_SOLNPOOL_FILTER_RANGE,
+CPX_SOLNPOOL_OBJ,
+CPX_SOLUTIONTARGET_AUTO,
+CPX_SOLUTIONTARGET_FIRSTORDER,
+CPX_SOLUTIONTARGET_OPTIMALCONVEX,
+CPX_SOLUTIONTARGET_OPTIMALGLOBAL,
+CPX_STAT_ABORT_DETTIME_LIM,
+CPX_STAT_ABORT_DUAL_OBJ_LIM,
+CPX_STAT_ABORT_IT_LIM,
+CPX_STAT_ABORT_OBJ_LIM,
+CPX_STAT_ABORT_PRIM_OBJ_LIM,
+CPX_STAT_ABORT_TIME_LIM,
+CPX_STAT_ABORT_USER,
+CPX_STAT_CONFLICT_ABORT_CONTRADICTION,
+CPX_STAT_CONFLICT_ABORT_DETTIME_LIM,
+CPX_STAT_CONFLICT_ABORT_IT_LIM,
+CPX_STAT_CONFLICT_ABORT_MEM_LIM,
+CPX_STAT_CONFLICT_ABORT_NODE_LIM,
+CPX_STAT_CONFLICT_ABORT_OBJ_LIM,
+CPX_STAT_CONFLICT_ABORT_TIME_LIM,
+CPX_STAT_CONFLICT_ABORT_USER,
+CPX_STAT_CONFLICT_FEASIBLE,
+CPX_STAT_CONFLICT_MINIMAL,
+CPX_STAT_FEASIBLE_RELAXED_INF,
+CPX_STAT_FEASIBLE_RELAXED_QUAD,
+CPX_STAT_FEASIBLE_RELAXED_SUM,
+CPX_STAT_FEASIBLE,
+CPX_STAT_FIRSTORDER,
+CPX_STAT_INFEASIBLE,
+CPX_STAT_INForUNBD,
+CPX_STAT_NUM_BEST,
+CPX_STAT_OPTIMAL_FACE_UNBOUNDED,
+CPX_STAT_OPTIMAL_INFEAS,
+CPX_STAT_OPTIMAL_RELAXED_INF,
+CPX_STAT_OPTIMAL_RELAXED_QUAD,
+CPX_STAT_OPTIMAL_RELAXED_SUM,
+CPX_STAT_OPTIMAL,
+CPX_STAT_UNBOUNDED,
+CPX_STR_PARAM_MAX,
+CPX_SUM_COMP_SLACK,
+CPX_SUM_DUAL_INFEAS,
+CPX_SUM_DUAL_RESIDUAL,
+CPX_SUM_INDSLACK_INFEAS,
+CPX_SUM_INT_INFEAS,
+CPX_SUM_PI,
+CPX_SUM_PRIMAL_INFEAS,
+CPX_SUM_PRIMAL_RESIDUAL,
+CPX_SUM_QCPRIMAL_RESIDUAL,
+CPX_SUM_QCSLACK_INFEAS,
+CPX_SUM_QCSLACK,
+CPX_SUM_RED_COST,
+CPX_SUM_SCALED_DUAL_INFEAS,
+CPX_SUM_SCALED_DUAL_RESIDUAL,
+CPX_SUM_SCALED_PI,
+CPX_SUM_SCALED_PRIMAL_INFEAS,
+CPX_SUM_SCALED_PRIMAL_RESIDUAL,
+CPX_SUM_SCALED_RED_COST,
+CPX_SUM_SCALED_SLACK,
+CPX_SUM_SCALED_X,
+CPX_SUM_SLACK,
+CPX_SUM_X,
+CPX_TUNE_ABORT,
+CPX_TUNE_AVERAGE,
+CPX_TUNE_DETTILIM,
+CPX_TUNE_MINMAX,
+CPX_TUNE_TILIM,
+CPX_TYPE_ANY,
+CPX_TYPE_SOS1,
+CPX_TYPE_SOS2,
+CPX_TYPE_USER,
+CPX_TYPE_VAR,
+CPX_USECUT_FILTER,
+CPX_USECUT_FORCE,
+CPX_USECUT_PURGE,
+CPX_VARSEL_DEFAULT,
+CPX_VARSEL_MAXINFEAS,
+CPX_VARSEL_MININFEAS,
+CPX_VARSEL_PSEUDO,
+CPX_VARSEL_PSEUDOREDUCED,
+CPX_VARSEL_STRONG,
+CPX_WRITELEVEL_ALLVARS,
+CPX_WRITELEVEL_AUTO,
+CPX_WRITELEVEL_DISCRETEVARS,
+CPX_WRITELEVEL_NONZERODISCRETEVARS,
+CPX_WRITELEVEL_NONZEROVARS,
+CPXERR_NEGATIVE_SURPLUS,
+CPXERR_NO_SENSIT,
+CPXMIP_ABORT_FEAS,
+CPXMIP_ABORT_INFEAS,
+CPXMIP_ABORT_RELAXED,
+CPXMIP_DETTIME_LIM_FEAS,
+CPXMIP_DETTIME_LIM_INFEAS,
+CPXMIP_FAIL_FEAS_NO_TREE,
+CPXMIP_FAIL_FEAS,
+CPXMIP_FAIL_INFEAS_NO_TREE,
+CPXMIP_FAIL_INFEAS,
+CPXMIP_FEASIBLE_RELAXED_INF,
+CPXMIP_FEASIBLE_RELAXED_QUAD,
+CPXMIP_FEASIBLE_RELAXED_SUM,
+CPXMIP_FEASIBLE,
+CPXMIP_INFEASIBLE,
+CPXMIP_INForUNBD,
+CPXMIP_MEM_LIM_FEAS,
+CPXMIP_MEM_LIM_INFEAS,
+CPXMIP_NODE_LIM_FEAS,
+CPXMIP_NODE_LIM_INFEAS,
+CPXMIP_OPTIMAL_INFEAS,
+CPXMIP_OPTIMAL_POPULATED_TOL,
+CPXMIP_OPTIMAL_POPULATED,
+CPXMIP_OPTIMAL_RELAXED_INF,
+CPXMIP_OPTIMAL_RELAXED_QUAD,
+CPXMIP_OPTIMAL_RELAXED_SUM,
+CPXMIP_OPTIMAL_TOL,
+CPXMIP_OPTIMAL,
+CPXMIP_POPULATESOL_LIM,
+CPXMIP_SOL_LIM,
+CPXMIP_TIME_LIM_FEAS,
+CPXMIP_TIME_LIM_INFEAS,
+CPXMIP_UNBOUNDED,
+CPXNET_NO_DISPLAY_OBJECTIVE,
+CPXNET_PENALIZED_OBJECTIVE,
+CPXNET_PRICE_AUTO,
+CPXNET_PRICE_MULT_PART,
+CPXNET_PRICE_PARTIAL,
+CPXNET_PRICE_SORT_MULT_PART,
+CPXNET_TRUE_OBJECTIVE,
+CPXPARAM_Advance,
+CPXPARAM_Barrier_Algorithm,
+CPXPARAM_Barrier_ColNonzeros,
+CPXPARAM_Barrier_ConvergeTol,
+CPXPARAM_Barrier_Crossover,
+CPXPARAM_Barrier_Display,
+CPXPARAM_Barrier_Limits_Corrections,
+CPXPARAM_Barrier_Limits_Growth,
+CPXPARAM_Barrier_Limits_Iteration,
+CPXPARAM_Barrier_Limits_ObjRange,
+CPXPARAM_Barrier_Ordering,
+CPXPARAM_Barrier_QCPConvergeTol,
+CPXPARAM_Barrier_StartAlg,
+CPXPARAM_ClockType,
+CPXPARAM_Conflict_Display,
+CPXPARAM_DetTimeLimit,
+CPXPARAM_DistMIP_Rampup_DetTimeLimit,
+CPXPARAM_DistMIP_Rampup_Duration,
+CPXPARAM_DistMIP_Rampup_TimeLimit,
+CPXPARAM_Emphasis_Memory,
+CPXPARAM_Emphasis_MIP,
+CPXPARAM_Emphasis_Numerical,
+CPXPARAM_Feasopt_Mode,
+CPXPARAM_Feasopt_Tolerance,
+CPXPARAM_LPMethod,
+CPXPARAM_MIP_Cuts_Cliques,
+CPXPARAM_MIP_Cuts_Covers,
+CPXPARAM_MIP_Cuts_Disjunctive,
+CPXPARAM_MIP_Cuts_FlowCovers,
+CPXPARAM_MIP_Cuts_Gomory,
+CPXPARAM_MIP_Cuts_GUBCovers,
+CPXPARAM_MIP_Cuts_Implied,
+CPXPARAM_MIP_Cuts_LiftProj,
+CPXPARAM_MIP_Cuts_MCFCut,
+CPXPARAM_MIP_Cuts_MIRCut,
+CPXPARAM_MIP_Cuts_PathCut,
+CPXPARAM_MIP_Cuts_ZeroHalfCut,
+CPXPARAM_MIP_Display,
+CPXPARAM_MIP_Interval,
+CPXPARAM_MIP_Limits_AggForCut,
+CPXPARAM_MIP_Limits_AuxRootThreads,
+CPXPARAM_MIP_Limits_CutPasses,
+CPXPARAM_MIP_Limits_CutsFactor,
+CPXPARAM_MIP_Limits_EachCutLimit,
+CPXPARAM_MIP_Limits_GomoryCand,
+CPXPARAM_MIP_Limits_GomoryPass,
+CPXPARAM_MIP_Limits_Nodes,
+CPXPARAM_MIP_Limits_PolishTime,
+CPXPARAM_MIP_Limits_Populate,
+CPXPARAM_MIP_Limits_ProbeDetTime,
+CPXPARAM_MIP_Limits_ProbeTime,
+CPXPARAM_MIP_Limits_RepairTries,
+CPXPARAM_MIP_Limits_Solutions,
+CPXPARAM_MIP_Limits_StrongCand,
+CPXPARAM_MIP_Limits_StrongIt,
+CPXPARAM_MIP_Limits_SubMIPNodeLim,
+CPXPARAM_MIP_Limits_TreeMemory,
+CPXPARAM_MIP_OrderType,
+CPXPARAM_MIP_PolishAfter_AbsMIPGap,
+CPXPARAM_MIP_PolishAfter_DetTime,
+CPXPARAM_MIP_PolishAfter_MIPGap,
+CPXPARAM_MIP_PolishAfter_Nodes,
+CPXPARAM_MIP_PolishAfter_Solutions,
+CPXPARAM_MIP_PolishAfter_Time,
+CPXPARAM_MIP_Pool_AbsGap,
+CPXPARAM_MIP_Pool_Capacity,
+CPXPARAM_MIP_Pool_Intensity,
+CPXPARAM_MIP_Pool_RelGap,
+CPXPARAM_MIP_Pool_Replace,
+CPXPARAM_MIP_Strategy_Backtrack,
+CPXPARAM_MIP_Strategy_BBInterval,
+CPXPARAM_MIP_Strategy_Branch,
+CPXPARAM_MIP_Strategy_CallbackReducedLP,
+CPXPARAM_MIP_Strategy_Dive,
+CPXPARAM_MIP_Strategy_File,
+CPXPARAM_MIP_Strategy_FPHeur,
+CPXPARAM_MIP_Strategy_HeuristicFreq,
+CPXPARAM_MIP_Strategy_KappaStats,
+CPXPARAM_MIP_Strategy_LBHeur,
+CPXPARAM_MIP_Strategy_MIQCPStrat,
+CPXPARAM_MIP_Strategy_NodeSelect,
+CPXPARAM_MIP_Strategy_Order,
+CPXPARAM_MIP_Strategy_PresolveNode,
+CPXPARAM_MIP_Strategy_Probe,
+CPXPARAM_MIP_Strategy_RINSHeur,
+CPXPARAM_MIP_Strategy_Search,
+CPXPARAM_MIP_Strategy_StartAlgorithm,
+CPXPARAM_MIP_Strategy_SubAlgorithm,
+CPXPARAM_MIP_Strategy_VariableSelect,
+CPXPARAM_MIP_Tolerances_AbsMIPGap,
+CPXPARAM_MIP_Tolerances_Integrality,
+CPXPARAM_MIP_Tolerances_LowerCutoff,
+CPXPARAM_MIP_Tolerances_MIPGap,
+CPXPARAM_MIP_Tolerances_ObjDifference,
+CPXPARAM_MIP_Tolerances_RelObjDifference,
+CPXPARAM_MIP_Tolerances_UpperCutoff,
+CPXPARAM_Network_Display,
+CPXPARAM_Network_Iterations,
+CPXPARAM_Network_NetFind,
+CPXPARAM_Network_Pricing,
+CPXPARAM_Network_Tolerances_Feasibility,
+CPXPARAM_Network_Tolerances_Optimality,
+CPXPARAM_Output_CloneLog,
+CPXPARAM_Output_IntSolFilePrefix,
+CPXPARAM_Output_MPSLong,
+CPXPARAM_Output_WriteLevel,
+CPXPARAM_Parallel,
+CPXPARAM_Preprocessing_Aggregator,
+CPXPARAM_Preprocessing_BoundStrength,
+CPXPARAM_Preprocessing_CoeffReduce,
+CPXPARAM_Preprocessing_Dependency,
+CPXPARAM_Preprocessing_Dual,
+CPXPARAM_Preprocessing_Fill,
+CPXPARAM_Preprocessing_Linear,
+CPXPARAM_Preprocessing_NumPass,
+CPXPARAM_Preprocessing_Presolve,
+CPXPARAM_Preprocessing_QCPDuals,
+CPXPARAM_Preprocessing_QPMakePSD,
+CPXPARAM_Preprocessing_Reduce,
+CPXPARAM_Preprocessing_Relax,
+CPXPARAM_Preprocessing_RepeatPresolve,
+CPXPARAM_Preprocessing_Symmetry,
+CPXPARAM_QPMethod,
+CPXPARAM_RandomSeed,
+CPXPARAM_Read_APIEncoding,
+CPXPARAM_Read_Constraints,
+CPXPARAM_Read_DataCheck,
+CPXPARAM_Read_FileEncoding,
+CPXPARAM_Read_Nonzeros,
+CPXPARAM_Read_QPNonzeros,
+CPXPARAM_Read_Scale,
+CPXPARAM_Read_Variables,
+CPXPARAM_ScreenOutput,
+CPXPARAM_Sifting_Algorithm,
+CPXPARAM_Sifting_Display,
+CPXPARAM_Sifting_Iterations,
+CPXPARAM_Simplex_Crash,
+CPXPARAM_Simplex_DGradient,
+CPXPARAM_Simplex_Display,
+CPXPARAM_Simplex_Limits_Iterations,
+CPXPARAM_Simplex_Limits_LowerObj,
+CPXPARAM_Simplex_Limits_Perturbation,
+CPXPARAM_Simplex_Limits_Singularity,
+CPXPARAM_Simplex_Limits_UpperObj,
+CPXPARAM_Simplex_Perturbation_Constant,
+CPXPARAM_Simplex_Perturbation_Indicator,
+CPXPARAM_Simplex_PGradient,
+CPXPARAM_Simplex_Pricing,
+CPXPARAM_Simplex_Refactor,
+CPXPARAM_Simplex_Tolerances_Feasibility,
+CPXPARAM_Simplex_Tolerances_Markowitz,
+CPXPARAM_Simplex_Tolerances_Optimality,
+CPXPARAM_SolutionTarget,
+CPXPARAM_Threads,
+CPXPARAM_TimeLimit,
+CPXPARAM_Tune_DetTimeLimit,
+CPXPARAM_Tune_Display,
+CPXPARAM_Tune_Measure,
+CPXPARAM_Tune_Repeat,
+CPXPARAM_Tune_TimeLimit,
+CPXPARAM_WorkDir,
+CPXPARAM_WorkMem,
+CPXPROB_FIXEDMILP,
+CPXPROB_FIXEDMIQP,
+CPXPROB_LP,
+CPXPROB_MILP,
+CPXPROB_MIQCP,
+CPXPROB_MIQP,
+CPXPROB_NODELP,
+CPXPROB_NODEQCP,
+CPXPROB_NODEQP,
+CPXPROB_QCP,
+CPXPROB_QP
+)

R/cplex.R

+#------------------------------------------------------------------------------#
+#                     R Interface to C API of IBM ILOG CPLEX                   #
+#------------------------------------------------------------------------------#
+
+#  cplex.R
+#  R Interface to C API of IBM ILOG CPLEX Version 12.1 to 12.6.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of cplexAPI.
+#
+#  CplexAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  CplexAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with cplexAPI.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+# for checkOptSol
+
+# return codes of ILOG CPLEX optimizations
+return_codeCPLEX <- function(code) {
+
+    if (code == 0) {
+        error <- "Optimization ended successfull"
+    } else {
+        error <- getErrorStrCPLEX(code)
+    }
+
+    return(error)
+
+}
+
+
+# status codes of ILOG CPLEX optimizations
+status_codeCPLEX <- function(env, code) {
+
+    return(getStatStrCPLEX(env, code))
+
+}
+
+
+#------------------------------------------------------------------------------#
+# get values and names of non-default parameters
+getParmValCPLEX <- function(env) {
+
+    parmCname <- getChgParmCPLEX(env)
+
+    if (!is.null(parmCname)) {
+
+        parmType     <- sapply(parmCname, function(x) getParmTypeCPLEX(env, x))
+        parmCnameStr <- sapply(parmCname, function(x) getParmNameCPLEX(env, x))
+
+        intVal <- sapply(parmCname[parmType == CPX_PARAMTYPE_INT],
+                         function(x) getIntParmCPLEX(env, x)
+                        )
+        dblVal <- sapply(parmCname[parmType == CPX_PARAMTYPE_DOUBLE],
+                         function(x) getDblParmCPLEX(env, x)
+                        )
+        strVal <- sapply(parmCname[parmType == CPX_PARAMTYPE_STRING],
+                         function(x) getStrParmCPLEX(env, x)
+                        )
+
+        names(intVal) <- parmCnameStr[parmType == CPX_PARAMTYPE_INT]
+        names(dblVal) <- parmCnameStr[parmType == CPX_PARAMTYPE_DOUBLE]
+        names(strVal) <- parmCnameStr[parmType == CPX_PARAMTYPE_STRING]
+
+        parms <- list(integer = intVal, double = dblVal, string = strVal)
+
+    }
+    else {
+        parms <- parmCname
+    }
+
+    return(parms)
+
+}
+
+
+

R/cplexErrorClass.R

+#------------------------------------------------------------------------------#
+#                     R Interface to C API of IBM ILOG CPLEX                   #
+#------------------------------------------------------------------------------#
+
+#  cpxerrClass.R
+#  R Interface to C API of IBM ILOG CPLEX Version 12.1 to 12.6.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of cplexAPI.
+#
+#  CplexAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  CplexAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with cplexAPI.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+#                       definition of class cplexError                         #
+#------------------------------------------------------------------------------#
+
+
+# representation of class cplexError
+setClass(Class = "cplexError",
+         representation(
+              errnum = "integer"
+         )
+)
+
+
+#------------------------------------------------------------------------------#
+
+# contructor for class cplexError
+cplexError <- function(err) {
+
+    if(is(err, "cpxerr")) {
+        cErr <- new("cplexError", errnum = as.integer(err))
+    }
+    else {
+        cErr <- err
+    }
+    
+    return(cErr)
+}
+
+
+#------------------------------------------------------------------------------#
+
+# errnum
+setMethod("errnum", signature(object = "cplexError"),
+          function(object) {
+              return(object@errnum)
+          }
+)
+
+setReplaceMethod("errnum", signature = (object = "cplexError"),
+                 function(object, value) {
+                     object@errnum <- value
+                     return(object)
+                 }
+)
+
+
+# err
+setMethod("err", signature(object = "cplexError"),
+          function(object) {
+              msg <- getErrorStrCPLEX(object@errnum)
+              return(msg)
+          }
+)
+
+
+# errmsg
+setMethod("errmsg", signature(object = "cplexError"),
+          function(object) {
+              msg <- getErrorStrCPLEX(object@errnum)
+              cat(msg)
+          }
+)
+
+
+#------------------------------------------------------------------------------#
+
+setMethod("show", signature(object = "cplexError"),
+    function(object) {
+    
+        cat("object of class ", dQuote("cplexError"), ".\n", sep = "")
+        cat(paste("Slot ", dQuote("errnum"), ": ",
+                  errnum(object), "\n", sep = ""))
+        cat(paste("Error string:  ", err(object), sep = ""))
+    }
+)

R/cplexPtrClass.R

+#------------------------------------------------------------------------------#
+#                     R Interface to C API of IBM ILOG CPLEX                   #
+#------------------------------------------------------------------------------#
+
+#  cplex_ptrClass.R
+#  R Interface to C API of IBM ILOG CPLEX Version 12.1 to 12.6.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of cplexAPI.
+#
+#  CplexAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  CplexAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with cplexAPI.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+#                         definition of class cplexPtr                         #
+#------------------------------------------------------------------------------#
+
+
+# representation of class cplexPtr
+setClass(Class = "cplexPtr",
+         representation(
+              cplexPtrType = "character",
+              cplexPointer = "externalptr"
+         )
+         #, contains = "externalptr"
+)
+
+
+#------------------------------------------------------------------------------#
+
+# contructor for class cplexPtr
+setMethod(f = "initialize",
+          signature = "cplexPtr",
+          definition = function(.Object, p, w) {
+
+              fn <- attr(p, which = "CPLEXfn", exact = TRUE)
+
+              .Object@cplexPointer <- attr(p, which = w, exact = TRUE)
+              .Object@cplexPtrType <- as.character(p)
+
+              attr(.Object@cplexPtrType, which = "CPLEXfn") <- fn
+              
+              return(.Object)
+          
+          }
+)
+
+
+# contructor for pointers to cplex envoronments
+cplex_ProbPointer <- function(pointer) {
+
+    if(is(pointer, "cplex_prob_ptr")) {
+        pObj <- new("cplexPtr",
+                    p = pointer,
+                    w = as.character("cplex_prob_ptr"))
+    }
+    else {
+        pObj <- pointer
+    }
+    
+    return(pObj)
+}
+
+# contructor for pointers to cplex problem onjects
+cplex_EnvPointer <- function(pointer) {
+
+    if(is(pointer, "cplex_env_ptr")) {
+        pObj <- new("cplexPtr",
+                    p = pointer,
+                    w = as.character("cplex_env_ptr"))
+    }
+    else {
+        pObj <- pointer
+    }
+    
+    return(pObj)
+}
+
+# contructor for pointers to cplex files
+cplex_FilePointer <- function(pointer) {
+
+    if(is(pointer, "cplex_file_ptr")) {
+        
+        pObj <- new("cplexPtr",
+                    p = pointer,
+                    w = as.character("cplex_file_ptr"))
+    }
+    else {
+        pObj <- pointer
+    }
+    
+    return(pObj)
+}
+
+# contructor for pointers to cplex channels
+cplex_ChannelPointer <- function(pointer, chname) {
+
+    chn <- ifelse(missing(chname), "cplex_chan_ptr", chname)
+
+    if(is(pointer, "cplex_chan_ptr")) {
+        pObj <- new("cplexPtr",
+                    p = pointer,
+                    w = as.character(chn))
+    }
+    else {
+        pObj <- pointer
+    }
+    
+    return(pObj)
+}
+
+# contructor for pointers to termination signals
+cplex_TermPointer <- function(pointer) {
+
+    if(is(pointer, "cplex_term_ptr")) {
+        pObj <- new("cplexPtr",
+                    p = pointer,
+                    w = as.character("cplex_term_ptr"))
+    }
+    else {
+        pObj <- pointer
+    }
+    
+    return(pObj)
+}
+
+
+#------------------------------------------------------------------------------#
+
+setMethod("isNULLpointerCPLEX", signature(object = "cplexPtr"),
+    function(object) {
+        return(.Call("isNULLptr",
+                     PACKAGE = "cplexAPI", cplexPointer(object)))
+    }
+)
+
+setMethod("isCPLEXprobPointer", signature(object = "cplexPtr"),
+    function(object) {
+        return(.Call("isCPLEXprobPtr",
+                     PACKAGE = "cplexAPI", cplexPointer(object)))
+    }
+)
+
+setMethod("isCPLEXenvPointer", signature(object = "cplexPtr"),
+    function(object) {
+        return(.Call("isCPLEXenvPtr",
+                     PACKAGE = "cplexAPI", cplexPointer(object)))
+    }
+)
+
+setMethod("isCPLEXfilePointer", signature(object = "cplexPtr"),
+    function(object) {
+        return(.Call("isCPLEXfilePtr",
+                     PACKAGE = "cplexAPI", cplexPointer(object)))
+    }
+)
+
+setMethod("isCPLEXchanPointer", signature(object = "cplexPtr"),
+    function(object) {
+        return(.Call("isCPLEXchanPtr",
+                     PACKAGE = "cplexAPI", cplexPointer(object)))
+    }
+)
+
+setMethod("isCPLEXtermPointer", signature(object = "cplexPtr"),
+    function(object) {
+        return(.Call("isCPLEXtermPtr", 
+                     PACKAGE = "cplexAPI", cplexPointer(object)))
+    }
+)
+
+
+#------------------------------------------------------------------------------#
+
+# cplexPtrType
+setMethod("cplexPtrType", signature(object = "cplexPtr"),
+          function(object) {
+              return(object@cplexPtrType)
+          }
+)
+
+setReplaceMethod("cplexPtrType", signature = (object = "cplexPtr"),
+                 function(object, value) {
+                     object@cplexPtrType <- value
+                     return(object)
+                 }
+)
+
+
+# cplexPointer
+setMethod("cplexPointer", signature(object = "cplexPtr"),
+          function(object) {
+              return(object@cplexPointer)
+          }
+)
+
+
+#------------------------------------------------------------------------------#
+
+setMethod("show", signature(object = "cplexPtr"),
+    function(object) {
+    
+        fn <- NA
+        
+        if (isNULLpointerCPLEX(object)) {
+            ptrtype <- "NULL"
+        }
+        else {
+            if (isCPLEXprobPointer(object)) {
+                ptrtype <- "CPLEX problem object"
+            }
+            else if (isCPLEXenvPointer(object)) {
+                ptrtype <- "CPLEX environment"
+            }
+            else if (isCPLEXfilePointer(object)) {
+                ptrtype <- "CPLEX file"
+                fn <- attr(cplexPtrType(object),
+                           which = "CPLEXfn", exact = TRUE)
+            }
+            else if (isCPLEXchanPointer(object)) {
+                ptrtype <- "CPLEX channel"
+            }
+            else if (isCPLEXtermPointer(object)) {
+                ptrtype <- "CPLEX termination signal"
+            }
+            else {
+                ptrtype <- "unknown"
+            }
+        }
+
+        cat("object of class ", dQuote("cplexPtr"),
+            ": pointer to ", ptrtype, ".\n", sep = "")
+        cat(paste("Slot ",
+                  dQuote("cplexPtrType"), ": ",
+                  cplexPtrType(object), "\n", sep = ""))
+        cat(paste("Slot ", dQuote("cplexPointer"), ": ", sep = ""))
+        print(slot(object, "cplexPointer"), sep = "")
+        if (!is.na(fn)) {
+            cat(paste("Filename:   ", dQuote(fn), "\n"))
+        }
+    }
+)
+
+
+#------------------------------------------------------------------------------#
+
+setMethod("summary", signature(object = "cplexPtr"),
+    function(object, ...) {
+
+        if (isNULLpointerCPLEX(object)) {
+            cat("NULL pointer\n")
+        }
+        else {
+            if (isCPLEXprobPointer(object)) {
+                cat("CPLEX problem object\n")
+                cat(paste("Number of variables:  ",
+                          getNumColsCPLEX(lp = object, ...), "\n"))
+                cat(paste("Number of constraints:",
+                          getNumRowsCPLEX(lp = object, ...), "\n"))
+                cat("\nSolution\n")
+                sol <- solutionCPLEX(lp = object, ...)
+                if (!is(sol, "cplexError")) {
+                    nc <- getNumColsCPLEX(lp = object, ...)
+                    nr <- getNumRowsCPLEX(lp = object, ...)
+                    cat(paste("solution status:",
+                              getStatStrCPLEX(stat = sol$lpstat, ...), "\n"))
+                    
+                    if (sol$lpstat == CPX_STAT_OPTIMAL) {
+                        if (nc > 10) {
+                            sx  <- paste(paste(round(sol$x[1:10], digits = 2),
+                                               collapse = "  ")
+                                         , "...")
+                            sdj <- paste(paste(round(sol$dj[1:10], digits = 2),
+                                               collapse = "  ")
+                                         , "...")
+                        }
+                        else {
+                            sx  <- paste(round(sol$x, digits = 2),
+                                         collapse = "  ")
+                            sdj <- paste(round(sol$dj, digits = 2),
+                                         collapse = "  ")
+                        }
+
+                        if (nr > 10) {
+                            pi <- paste(paste(round(sol$pi[1:10], digits = 2),
+                                              collapse = "  ")
+                                        , "...")
+                            sl <- paste(paste(round(sol$slack[1:10],digits = 2),
+                                              collapse = "  ")
+                                        , "...")
+                        }
+                        else {
+                            pi <- paste(round(sol$pi, digits = 2),
+                                        collapse = "  ")
+                            sl <- paste(round(sol$slack, digits = 2),
+                                        collapse = "  ")
+                        }
+
+                        cat(paste("objective value:       ", sol$objval, "\n"))
+                        cat(paste("variable values:       ", sx, "\n"))
+                        cat(paste("dual variable values:  ", pi, "\n"))
+                        cat(paste("slack variable values: ", sl, "\n"))
+                        cat(paste("variable reduced costs:", sdj, "\n"))
+                    }
+
+                    cat("\nSolution information\n")
+                    soln <- solnInfoCPLEX(lp = object, ...)
+                    cat(paste("method:         ", soln$method, "\n"))
+                    cat(paste("solution type:  ", soln$type, "\n"))
+                    cat(paste("primal feasible:", soln$primal_feasible, "\n"))
+                    cat(paste("dual feasible:  ", soln$dual_feasible, "\n"))
+
+                }
+            }
+            else if (isCPLEXenvPointer(object)) {
+                cat("CPLEX environment\n")
+            }
+            else if (isCPLEXfilePointer(object)) {
+                cat("CPLEX file\n")
+            }
+            else if (isCPLEXchanPointer(object)) {
+                cat("CPLEX channel\n")
+            }
+            else if (isCPLEXtermPointer(object)) {
+                cat("CPLEX termination signal\n")
+            }
+            else {
+                cat("unknown pointer\n")
+            }
+        }
+        return(invisible(NULL))
+    }
+)

R/cplex_checkAPI.R

+#------------------------------------------------------------------------------#
+#                     R Interface to C API of IBM ILOG CPLEX                   #
+#------------------------------------------------------------------------------#
+
+#  cplex_checkAPI.R
+#  R Interface to C API of IBM ILOG CPLEX Version 12.1 to 12.6.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of cplexAPI.
+#
+#  CplexAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  CplexAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with cplexAPI.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+#                              the interface (check)                           #
+#------------------------------------------------------------------------------#
+
+checkCopyLpCPLEX <- function(env, lp, nCols, nRows, lpdir, objf, rhs, sense,
+                             matbeg, matcnt, matind, matval, lb, ub,
+                             rngval = NULL
+                            ) {
+
+    if (is.null(rngval)) {
+        Crngval <- as.null(rngval)
+    }
+    else {
+        Crngval <- as.numeric(rngval)
+    }
+
+    status <- .Call("checkCopyLp", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.integer(nCols),
+                    as.integer(nRows),
+                    as.integer(lpdir),
+                    as.numeric(objf),
+                    as.numeric(rhs),
+                    as.character(paste(sense, collapse = "")),
+                    as.integer(matbeg),
+                    as.integer(matcnt),
+                    as.integer(matind),
+                    as.numeric(matval),
+                    as.numeric(lb),
+                    as.numeric(ub),
+                    Crngval
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkCopyLpwNamesCPLEX <- function(env, lp, nCols, nRows, lpdir, objf, rhs,
+                                   sense, matbeg, matcnt, matind, matval,
+                                   lb, ub, rngval = NULL,
+                                   cnames = NULL, rnames = NULL) {
+
+    if (is.null(rngval)) {
+        Crngval <- as.null(rngval)
+    }
+    else {
+        Crngval <- as.numeric(rngval)
+    }
+
+    if (is.null(cnames)) {
+        Ccnames <- as.null(cnames)
+    }
+    else {
+        Ccnames <- as.character(cnames)
+    }
+
+    if (is.null(rnames)) {
+        Crnames <- as.null(rnames)
+    }
+    else {
+        Crnames <- as.character(rnames)
+    }
+
+    status <- .Call("checkCopyLpwNames", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.integer(nCols),
+                    as.integer(nRows),
+                    as.integer(lpdir),
+                    as.numeric(objf),
+                    as.numeric(rhs),
+                    as.character(paste(sense, collapse = "")),
+                    as.integer(matbeg),
+                    as.integer(matcnt),
+                    as.integer(matind),
+                    as.numeric(matval),
+                    as.numeric(lb),
+                    as.numeric(ub),
+                    Crngval,
+                    Ccnames,
+                    Crnames
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkCopyQuadCPLEX <- function(env, lp, qmatbeg, qmatcnt, qmatind, qmatval) {
+
+    status <- .Call("checkCopyQuad", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.integer(qmatbeg),
+                    as.integer(qmatcnt),
+                    as.integer(qmatind),
+                    as.numeric(qmatval)
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkCopyQPsepCPLEX <- function(env, lp, qsepvec) {
+
+    status <- .Call("checkCopyQPsep", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.numeric(qsepvec)
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkAddRowsCPLEX <- function(env, lp, ncols, nrows, nnz,
+                              matbeg, matind, matval,
+                              rhs = NULL, sense = NULL,
+                              cnames = NULL, rnames = NULL) {
+
+    if (is.null(rhs)) {
+        Crhs <- as.null(rhs)
+    }
+    else {
+        Crhs <- as.numeric(rhs)
+    }
+
+    if (is.null(sense)) {
+        Csense <- as.null(sense)
+    }
+    else {
+        Csense <- as.character(paste(sense, collapse = ""))
+    }
+
+    if (is.null(cnames)) {
+        Ccnames <- as.null(cnames)
+    }
+    else {
+        Ccnames <- as.character(cnames)
+    }
+
+    if (is.null(rnames)) {
+        Crnames <- as.null(rnames)
+    }
+    else {
+        Crnames <- as.character(rnames)
+    }
+
+    status <- .Call("checkAddRows", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.integer(ncols),
+                    as.integer(nrows),
+                    as.integer(nnz),
+                    Crhs,
+                    Csense,
+                    as.integer(matbeg),
+                    as.integer(matind),
+                    as.numeric(matval),
+                    Ccnames,
+                    Crnames
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkAddColsCPLEX <- function(env, lp, ncols, nnz, objf, matbeg, matind, matval,
+                              lb = NULL, ub = NULL, cnames = NULL) {
+
+    if (is.null(lb)) {
+        Clb <- as.null(lb)
+    }
+    else {
+        Clb <- as.numeric(lb)
+    }
+
+    if (is.null(ub)) {
+        Cub <- as.null(ub)
+    }
+    else {
+        Cub <- as.numeric(ub)
+    }
+
+    if (is.null(cnames)) {
+        Ccnames <- as.null(cnames)
+    }
+    else {
+        Ccnames <- as.character(cnames)
+    }
+
+    status <- .Call("checkAddCols", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.integer(ncols),
+                    as.integer(nnz),
+                    as.numeric(objf),
+                    as.integer(matbeg),
+                    as.integer(matind),
+                    as.numeric(matval),
+                    Clb,
+                    Cub,
+                    Ccnames
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkChgCoefListCPLEX <- function(env, lp, nnz, ia, ja, ra) {
+
+    status <- .Call("checkChgCoefList", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.integer(nnz),
+                    as.integer(ia),
+                    as.integer(ja),
+                    as.numeric(ra)
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkCopyColTypeCPLEX <- function(env, lp, xctype) {
+
+    status <- .Call("checkCopyColType", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.character(paste(xctype, collapse = ""))
+              )
+
+    return(status)
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkValsCPLEX <- function(env, lp, nval,
+                           rind = NULL, cind = NULL, val = NULL) {
+
+    if (is.null(rind)) {
+        Crind <- as.null(rind)
+    }
+    else {
+        Crind <- as.integer(rind)
+    }
+
+    if (is.null(cind)) {
+        Ccind <- as.null(cind)
+    }
+    else {
+        Ccind <- as.integer(cind)
+    }
+
+    if (is.null(val)) {
+        Cval <- as.null(val)
+    }
+    else {
+        Cval <- as.numeric(val)
+    }
+
+    status <- .Call("checkVals", PACKAGE = "cplexAPI",
+                    cplexPointer(env),
+                    cplexPointer(lp),
+                    as.integer(nval),
+                    Crind,
+                    Ccind,
+                    Cval
+              )
+
+    return(status)
+}
+

R/zzz.R

+#------------------------------------------------------------------------------#
+#                     R Interface to C API of IBM ILOG CPLEX                   #
+#------------------------------------------------------------------------------#
+
+#  zzz.R
+#  R Interface to C API of IBM ILOG CPLEX Version 12.1 to 12.6.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of cplexAPI.
+#
+#  CplexAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  CplexAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with cplexAPI.  If not, see <http://www.gnu.org/licenses/>.
+
+
+.packageName <- "cplexAPI"
+
+.onLoad <- function(libname, pkgname) {
+    .Call("initCPLEX", PACKAGE = "cplexAPI")
+}
+
+#.onAttach <- function(libname, pkgname) {
+#    tmp <- openEnvCPLEX()
+#    packageStartupMessage("using IBM ILOG CPLEX version ", getVersionCPLEX(tmp))
+#    closeEnvCPLEX(tmp)
+#}