rLindo
R Interface to LINDO API

Package index
Search the rLindo package
Vignettes
Functions
2095
Source code
4
Man pages
284
Home
/
CRAN
/
rLindo
/
R/rLindo.R

R/rLindo.R
In rLindo: R Interface to LINDO API

Defines functions rLScreateEnv rLScreateModel rLSdeleteEnv rLSdeleteModel rLScopyParam rLSreadMPSFile rLSwriteMPSFile rLSreadLINDOFile rLSwriteLINDOFile rLSreadLINDOStream rLSwriteLINGOFile rLSwriteDualMPSFile rLSwriteSolution rLSwriteSolutionOfType rLSwriteIIS rLSwriteIUS rLSreadMPIFile rLSwriteMPIFile rLSwriteWithSetsAndSC rLSreadBasis rLSwriteBasis rLSreadLPFile rLSreadLPStream rLSsetPrintLogNull rLSgetErrorMessage rLSgetFileError rLSgetErrorRowIndex rLSsetModelDouParameter rLSgetModelDouParameter rLSsetModelIntParameter rLSgetModelIntParameter rLSsetEnvDouParameter rLSgetEnvDouParameter rLSsetEnvIntParameter rLSgetEnvIntParameter rLSreadModelParameter rLSreadEnvParameter rLSwriteModelParameter rLSgetIntParameterRange rLSgetDouParameterRange rLSgetParamShortDesc rLSgetParamLongDesc rLSgetParamMacroName rLSgetParamMacroID rLSloadLPData rLSloadQCData rLSloadConeData rLSloadSETSData rLSloadSemiContData rLSloadVarType rLSloadNameData rLSloadNLPData rLSloadInstruct rLSaddInstruct rLSloadStringData rLSloadString rLSdeleteStringData rLSdeleteString rLSgetStringValue rLSgetConstraintProperty rLSsetConstraintProperty rLSloadMultiStartSolution rLSloadGASolution rLSloadBasis rLSloadVarPriorities rLSreadVarPriorities rLSloadVarStartPoint rLSloadVarStartPointPartial rLSloadMIPVarStartPoint rLSloadMIPVarStartPointPartial rLSreadVarStartPoint rLSloadBlockStructure rLSoptimize rLSsolveMIP rLSsolveGOP rLSoptimizeQP rLScheckConvexity rLSsolveSBD rLSgetIInfo rLSgetDInfo rLSgetPrimalSolution rLSgetDualSolution rLSgetReducedCosts rLSgetReducedCostsCone rLSgetSlacks rLSgetBasis rLSgetSolution rLSgetMIPPrimalSolution rLSgetMIPDualSolution rLSgetMIPReducedCosts rLSgetMIPSlacks rLSgetMIPBasis rLSgetNextBestMIPSol rLSgetLPData rLSgetQCData rLSgetQCDatai rLSgetVarType rLSgetVarStartPoint rLSgetVarStartPointPartial rLSgetMIPVarStartPointPartial rLSgetMIPVarStartPoint rLSgetSETSData rLSgetSETSDatai rLSgetSemiContData rLSgetLPVariableDataj rLSgetVariableNamej rLSgetVariableIndex rLSgetConstraintNamei rLSgetConstraintIndex rLSgetConstraintDatai rLSgetLPConstraintDatai rLSgetConeNamei rLSgetConeIndex rLSgetConeDatai rLSgetNLPData rLSgetNLPConstraintDatai rLSgetNLPVariableDataj rLSgetNLPObjectiveData rLSgetDualModel rLScalinfeasMIPsolution rLSgetRoundMIPsolution rLSgetRangeData rLSaddConstraints rLSaddVariables rLSaddCones rLSaddSETS rLSaddQCterms rLSdeleteConstraints rLSdeleteCones rLSdeleteSETS rLSdeleteSemiContVars rLSdeleteVariables rLSdeleteQCterms rLSdeleteAj rLSmodifyLowerBounds rLSmodifyUpperBounds rLSmodifyRHS rLSmodifyObjective rLSmodifyAj rLSmodifyCone rLSmodifySET rLSmodifySemiContVars rLSmodifyConstraintType rLSmodifyVariableType rLSaddNLPAj rLSaddNLPobj rLSdeleteNLPobj rLSgetConstraintRanges rLSgetObjectiveRanges rLSgetBoundRanges rLSgetBestBounds rLSfindIIS rLSfindIUS rLSfindBlockStructure rLSgetIIS rLSgetIUS rLSgetBlockStructure rLSfreeSolverMemory rLSfreeHashMemory rLSfreeSolutionMemory rLSfreeMIPSolutionMemory rLSfreeGOPSolutionMemory rLSsetProbAllocSizes rLSsetProbNameAllocSizes rLSaddEmptySpacesAcolumns rLSaddEmptySpacesNLPAcolumns rLSwriteDeteqMPSFile rLSwriteDeteqLINDOFile rLSwriteSMPSFile rLSreadSMPSFile rLSwriteSMPIFile rLSreadSMPIFile rLSwriteScenarioSolutionFile rLSwriteNodeSolutionFile rLSwriteScenarioMPIFile rLSwriteScenarioMPSFile rLSwriteScenarioLINDOFile rLSsetModelStocDouParameter rLSgetModelStocDouParameter rLSsetModelStocIntParameter rLSgetModelStocIntParameter rLSgetScenarioIndex rLSgetStageIndex rLSgetStocParIndex rLSgetStocParName rLSgetScenarioName rLSgetStageName rLSgetStocIInfo rLSgetStocDInfo rLSgetStocSInfo rLSgetStocCCPIInfo rLSgetStocCCPDInfo rLSgetStocCCPSInfo rLSloadSampleSizes rLSloadConstraintStages rLSloadVariableStages rLSloadStageData rLSloadStocParData rLSloadStocParNames rLSgetDeteqModel rLSaggregateStages rLSgetStageAggScheme rLSdeduceStages rLSsolveSP rLSsolveHS rLSgetScenarioObjective rLSgetNodePrimalSolution rLSgetNodeDualSolution rLSgetNodeReducedCost rLSgetNodeSlacks rLSgetScenarioPrimalSolution rLSgetScenarioReducedCost rLSgetScenarioDualSolution rLSgetScenarioSlacks rLSgetNodeListByScenario rLSgetProbabilityByScenario rLSgetProbabilityByNode rLSgetStocParData rLSaddDiscreteBlocks rLSaddScenario rLSaddDiscreteIndep rLSaddParamDistIndep rLSaddChanceConstraint rLSsetNumStages rLSgetStocParOutcomes rLSloadCorrelationMatrix rLSgetCorrelationMatrix rLSgetStocParSample rLSgetDiscreteBlocks rLSgetDiscreteBlockOutcomes rLSgetDiscreteIndep rLSgetParamDistIndep rLSgetScenario rLSgetChanceConstraint rLSgetSampleSizes rLSgetConstraintStages rLSgetVariableStages rLSgetStocRowIndices rLSsetStocParRG rLSgetScenarioModel rLSfreeStocMemory rLSfreeStocHashMemory rLSgetModelStocParameterInt rLSgetModelStocParameterDou rLSgetModelStocParameterChar rLSsetModelStocParameterInt rLSsetModelStocParameterDou rLSsetModelStocParameterChar rLSgetEnvStocParameterInt rLSgetEnvStocParameterDou rLSgetEnvStocParameterChar rLSsetEnvStocParameterInt rLSsetEnvStocParameterDou rLSsetEnvStocParameterChar rLSsampCreate rLSsampDelete rLSsampSetDistrParam rLSsampGetDistrParam rLSsampEvalDistr rLSsampEvalUserDistr rLSsampSetRG rLSsampGenerate rLSsampGetPoints rLSsampLoadPoints rLSsampGetCIPoints rLSsampLoadDiscretePdfTable rLSsampGetDiscretePdfTable rLSsampGetIInfo rLSsampGetDInfo rLScreateRG rLScreateRGMT rLSgetDoubleRV rLSgetInt32RV rLSsetRGSeed rLSdisposeRG rLSsetDistrParamRG rLSsetDistrRG rLSgetDistrRV rLSgetInitSeed rLSgetRGNumThreads rLSfillRGBuffer rLSsolveFileLP rLSsolveMipBnp

Documented in rLSaddChanceConstraint rLSaddCones rLSaddConstraints rLSaddDiscreteBlocks rLSaddDiscreteIndep rLSaddEmptySpacesAcolumns rLSaddEmptySpacesNLPAcolumns rLSaddInstruct rLSaddNLPAj rLSaddNLPobj rLSaddParamDistIndep rLSaddQCterms rLSaddScenario rLSaddSETS rLSaddVariables rLSaggregateStages rLScalinfeasMIPsolution rLScheckConvexity rLScopyParam rLScreateEnv rLScreateModel rLScreateRG rLScreateRGMT rLSdeduceStages rLSdeleteAj rLSdeleteCones rLSdeleteConstraints rLSdeleteEnv rLSdeleteModel rLSdeleteNLPobj rLSdeleteQCterms rLSdeleteSemiContVars rLSdeleteSETS rLSdeleteString rLSdeleteStringData rLSdeleteVariables rLSdisposeRG rLSfillRGBuffer rLSfindBlockStructure rLSfindIIS rLSfindIUS rLSfreeGOPSolutionMemory rLSfreeHashMemory rLSfreeMIPSolutionMemory rLSfreeSolutionMemory rLSfreeSolverMemory rLSfreeStocHashMemory rLSfreeStocMemory rLSgetBasis rLSgetBestBounds rLSgetBlockStructure rLSgetBoundRanges rLSgetChanceConstraint rLSgetConeDatai rLSgetConeIndex rLSgetConeNamei rLSgetConstraintDatai rLSgetConstraintIndex rLSgetConstraintNamei rLSgetConstraintProperty rLSgetConstraintRanges rLSgetConstraintStages rLSgetCorrelationMatrix rLSgetDeteqModel rLSgetDInfo rLSgetDiscreteBlockOutcomes rLSgetDiscreteBlocks rLSgetDiscreteIndep rLSgetDistrRV rLSgetDoubleRV rLSgetDouParameterRange rLSgetDualModel rLSgetDualSolution rLSgetEnvDouParameter rLSgetEnvIntParameter rLSgetEnvStocParameterChar rLSgetEnvStocParameterDou rLSgetEnvStocParameterInt rLSgetErrorMessage rLSgetErrorRowIndex rLSgetFileError rLSgetIInfo rLSgetIIS rLSgetInitSeed rLSgetInt32RV rLSgetIntParameterRange rLSgetIUS rLSgetLPConstraintDatai rLSgetLPData rLSgetLPVariableDataj rLSgetMIPBasis rLSgetMIPDualSolution rLSgetMIPPrimalSolution rLSgetMIPReducedCosts rLSgetMIPSlacks rLSgetMIPVarStartPoint rLSgetMIPVarStartPointPartial rLSgetModelDouParameter rLSgetModelIntParameter rLSgetModelStocDouParameter rLSgetModelStocIntParameter rLSgetModelStocParameterChar rLSgetModelStocParameterDou rLSgetModelStocParameterInt rLSgetNextBestMIPSol rLSgetNLPConstraintDatai rLSgetNLPData rLSgetNLPObjectiveData rLSgetNLPVariableDataj rLSgetNodeDualSolution rLSgetNodeListByScenario rLSgetNodePrimalSolution rLSgetNodeReducedCost rLSgetNodeSlacks rLSgetObjectiveRanges rLSgetParamDistIndep rLSgetParamLongDesc rLSgetParamMacroID rLSgetParamMacroName rLSgetParamShortDesc rLSgetPrimalSolution rLSgetProbabilityByNode rLSgetProbabilityByScenario rLSgetQCData rLSgetQCDatai rLSgetRangeData rLSgetReducedCosts rLSgetReducedCostsCone rLSgetRoundMIPsolution rLSgetSampleSizes rLSgetScenario rLSgetScenarioDualSolution rLSgetScenarioIndex rLSgetScenarioModel rLSgetScenarioName rLSgetScenarioObjective rLSgetScenarioPrimalSolution rLSgetScenarioReducedCost rLSgetScenarioSlacks rLSgetSemiContData rLSgetSETSData rLSgetSETSDatai rLSgetSlacks rLSgetSolution rLSgetStageAggScheme rLSgetStageIndex rLSgetStageName rLSgetStocCCPDInfo rLSgetStocCCPIInfo rLSgetStocCCPSInfo rLSgetStocDInfo rLSgetStocIInfo rLSgetStocParData rLSgetStocParIndex rLSgetStocParName rLSgetStocParOutcomes rLSgetStocParSample rLSgetStocRowIndices rLSgetStocSInfo rLSgetStringValue rLSgetVariableIndex rLSgetVariableNamej rLSgetVariableStages rLSgetVarStartPoint rLSgetVarStartPointPartial rLSgetVarType rLSloadBasis rLSloadBlockStructure rLSloadConeData rLSloadConstraintStages rLSloadCorrelationMatrix rLSloadGASolution rLSloadInstruct rLSloadLPData rLSloadMIPVarStartPoint rLSloadMIPVarStartPointPartial rLSloadMultiStartSolution rLSloadNameData rLSloadNLPData rLSloadQCData rLSloadSampleSizes rLSloadSemiContData rLSloadSETSData rLSloadStageData rLSloadStocParData rLSloadStocParNames rLSloadString rLSloadStringData rLSloadVariableStages rLSloadVarPriorities rLSloadVarStartPoint rLSloadVarStartPointPartial rLSloadVarType rLSmodifyAj rLSmodifyCone rLSmodifyConstraintType rLSmodifyLowerBounds rLSmodifyObjective rLSmodifyRHS rLSmodifySemiContVars rLSmodifySET rLSmodifyUpperBounds rLSmodifyVariableType rLSoptimize rLSoptimizeQP rLSreadBasis rLSreadEnvParameter rLSreadLINDOFile rLSreadLINDOStream rLSreadLPFile rLSreadLPStream rLSreadModelParameter rLSreadMPIFile rLSreadMPSFile rLSreadSMPIFile rLSreadSMPSFile rLSreadVarPriorities rLSreadVarStartPoint rLSsampCreate rLSsampDelete rLSsampEvalDistr rLSsampEvalUserDistr rLSsampGenerate rLSsampGetCIPoints rLSsampGetDInfo rLSsampGetDiscretePdfTable rLSsampGetDistrParam rLSsampGetIInfo rLSsampGetPoints rLSsampLoadDiscretePdfTable rLSsampLoadPoints rLSsampSetDistrParam rLSsampSetRG rLSsetConstraintProperty rLSsetDistrParamRG rLSsetDistrRG rLSsetEnvDouParameter rLSsetEnvIntParameter rLSsetEnvStocParameterChar rLSsetEnvStocParameterDou rLSsetEnvStocParameterInt rLSsetModelDouParameter rLSsetModelIntParameter rLSsetModelStocDouParameter rLSsetModelStocIntParameter rLSsetModelStocParameterChar rLSsetModelStocParameterDou rLSsetModelStocParameterInt rLSsetNumStages rLSsetPrintLogNull rLSsetProbAllocSizes rLSsetProbNameAllocSizes rLSsetRGSeed rLSsetStocParRG rLSsolveFileLP rLSsolveGOP rLSsolveHS rLSsolveMIP rLSsolveMipBnp rLSsolveSBD rLSsolveSP rLSwriteBasis rLSwriteDeteqLINDOFile rLSwriteDeteqMPSFile rLSwriteDualMPSFile rLSwriteIIS rLSwriteIUS rLSwriteLINDOFile rLSwriteLINGOFile rLSwriteModelParameter rLSwriteMPIFile rLSwriteMPSFile rLSwriteNodeSolutionFile rLSwriteScenarioLINDOFile rLSwriteScenarioMPIFile rLSwriteScenarioMPSFile rLSwriteScenarioSolutionFile rLSwriteSMPIFile rLSwriteSMPSFile rLSwriteSolution rLSwriteSolutionOfType rLSwriteWithSetsAndSC 

#rLindo.R
#The R interface to LINDO API 8.0.
#This file includes all R interface wrapper functions for LINDO API C functions.
#Copyright (C) 2013 LINDO Systems.


#************************************************************##
# Structure Creation and Deletion Routines (5)                #
#*************************************************************#
rLScreateEnv <- function(){

    ans <- .Call("rcLScreateEnv", PACKAGE = "rLindo")
    return(ans)
}

rLScreateModel <- function(env){

    ans <- .Call("rcLScreateModel", PACKAGE = "rLindo", env)
    return(ans)
}

rLSdeleteEnv <- function(env){

    ans <- .Call("rcLSdeleteEnv", PACKAGE = "rLindo", env)
    return(ans)
}

rLSdeleteModel <- function(model){

    ans <- .Call("rcLSdeleteModel", PACKAGE = "rLindo", model)
    return(ans)
}

rLScopyParam <- function(smodel, tmodel, nSolverType){

    ans <- .Call("rcLScopyParam", PACKAGE = "rLindo", smodel,tmodel,as.integer(nSolverType))
    return(ans)
}

#*************************************************************#
# Model I-O Routines (18)                                     #
#*************************************************************#
rLSreadMPSFile <- function(model, pszFname, nFormat){

    ans <- .Call("rcLSreadMPSFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname),
                 as.integer(nFormat))
    return(ans)
}

rLSwriteMPSFile <- function(model, pszFname, nFormat){

    ans <- .Call("rcLSwriteMPSFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname),
                 as.integer(nFormat))
    return(ans)
}

rLSreadLINDOFile <- function(model, pszFname){

    ans <- .Call("rcLSreadLINDOFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSwriteLINDOFile <- function(model, pszFname){

    ans <- .Call("rcLSwriteLINDOFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSreadLINDOStream <- function(model, pszStream, nStreamLen){

    ans <- .Call("rcLSreadLINDOStream", PACKAGE = "rLindo", 
                 model,
                 as.character(pszStream),
                 as.integer(nStreamLen))
    return(ans)
}

rLSwriteLINGOFile <- function(model, pszFname){

    ans <- .Call("rcLSwriteLINGOFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSwriteDualMPSFile <- function(model, pszFname, nFormat, nObjSense){

    ans <- .Call("rcLSwriteDualMPSFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname),
                 as.integer(nFormat),
                 as.integer(nObjSense))
    return(ans)
}

rLSwriteSolution <- function(model, pszFname){

    ans <- .Call("rcLSwriteSolution", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSwriteSolutionOfType <- function(model, pszFname, nFormat){

    ans <- .Call("rcLSwriteSolutionOfType", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname),
                 as.integer(nFormat))
    return(ans)
}

rLSwriteIIS <- function(model, pszFname){

    ans <- .Call("rcLSwriteIIS", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSwriteIUS <- function(model, pszFname){

    ans <- .Call("rcLSwriteIUS", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSreadMPIFile <- function(model, pszFname){

    ans <- .Call("rcLSreadMPIFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSwriteMPIFile <- function(model, pszFname){

    ans <- .Call("rcLSwriteMPIFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSwriteWithSetsAndSC <- function(model, pszFname, nFormat){

    ans <- .Call("rcLSwriteWithSetsAndSC", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname),
                 as.integer(nFormat))
    return(ans)
}

rLSreadBasis <- function(model, pszFname, nFormat){

    ans <- .Call("rcLSreadBasis", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname),
                 as.integer(nFormat))
    return(ans)
}

rLSwriteBasis <- function(model, pszFname, nFormat){

    ans <- .Call("rcLSwriteBasis", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname),
                 as.integer(nFormat))
    return(ans)
}

rLSreadLPFile <- function(model, pszFname){

    ans <- .Call("rcLSreadLPFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSreadLPStream <- function(model, pszStream, nStreamLen){

    ans <- .Call("rcLSreadLPStream", PACKAGE = "rLindo", 
                 model,
                 as.character(pszStream),
                 as.integer(nStreamLen))
    return(ans)
}

rLSsetPrintLogNull <- function(model){

    ans <- .Call("rcLSsetPrintLogNull", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

#*************************************************************#
# Error Handling Routines (3)                                 #
#*************************************************************#
rLSgetErrorMessage <- function(env, errorcode){

    ans <- .Call("rcLSgetErrorMessage", PACKAGE = "rLindo", 
                 env,
                 as.integer(errorcode))
    return(ans)
}

rLSgetFileError <- function(model){

    ans <- .Call("rcLSgetFileError", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetErrorRowIndex <- function(model){

    ans <- .Call("rcLSgetErrorRowIndex", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

#*************************************************************#
# Routines for Setting and Retrieving Parameter Values (17)   #
#*************************************************************#
rLSsetModelDouParameter <- function(model,nParameter,dValue){

    ans <- .Call("rcLSsetModelDouParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(nParameter),
                 as.numeric(dValue))
    return(ans)
}

rLSgetModelDouParameter <- function(model,nParameter){

    ans <- .Call("rcLSgetModelDouParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(nParameter))
    return(ans)
}

rLSsetModelIntParameter <- function(model,nParameter,nValue){

    ans <- .Call("rcLSsetModelIntParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(nParameter),
                 as.integer(nValue))
    return(ans)
}

rLSgetModelIntParameter <- function(model,nParameter){

    ans <- .Call("rcLSgetModelIntParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(nParameter))
    return(ans)
}

rLSsetEnvDouParameter <- function(env,nParameter,dValue){

    ans <- .Call("rcLSsetEnvDouParameter", PACKAGE = "rLindo", 
                 env,
                 as.integer(nParameter),
                 as.numeric(dValue))
    return(ans)
}

rLSgetEnvDouParameter <- function(env,nParameter){

    ans <- .Call("rcLSgetEnvDouParameter", PACKAGE = "rLindo", 
                 env,
                 as.integer(nParameter))
    return(ans)
}

rLSsetEnvIntParameter <- function(env,nParameter,nValue){

    ans <- .Call("rcLSsetEnvIntParameter", PACKAGE = "rLindo", 
                 env,
                 as.integer(nParameter),
                 as.integer(nValue))
    return(ans)
}

rLSgetEnvIntParameter <- function(env,nParameter){

    ans <- .Call("rcLSgetEnvIntParameter", PACKAGE = "rLindo", 
                 env,
                 as.integer(nParameter))
    return(ans)
}

rLSreadModelParameter <- function(model,pszFname){

    ans <- .Call("rcLSreadModelParameter", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSreadEnvParameter <- function(env,pszFname){

    ans <- .Call("rcLSreadEnvParameter", PACKAGE = "rLindo", 
                 env,
                 as.character(pszFname))
    return(ans)
}

rLSwriteModelParameter <- function(model,pszFname){

    ans <- .Call("rcLSwriteModelParameter", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))
    return(ans)
}

rLSgetIntParameterRange <- function(model,nParameter){

    ans <- .Call("rcLSgetIntParameterRange", PACKAGE = "rLindo", 
                 model,
                 as.integer(nParameter))
    return(ans)
}

rLSgetDouParameterRange <- function(model,nParameter){

    ans <- .Call("rcLSgetDouParameterRange", PACKAGE = "rLindo", 
                 model,
                 as.integer(nParameter))
    return(ans)
}

rLSgetParamShortDesc <- function(env,nParam){

    ans <- .Call("rcLSgetParamShortDesc", PACKAGE = "rLindo", 
                 env,
                 as.integer(nParam))
    return(ans)
}

rLSgetParamLongDesc <- function(env,nParam){

    ans <- .Call("rcLSgetParamLongDesc", PACKAGE = "rLindo", 
                 env,
                 as.integer(nParam))
    return(ans)
}

rLSgetParamMacroName <- function(env,nParam){

    ans <- .Call("rcLSgetParamMacroName", PACKAGE = "rLindo", 
                 env,
                 as.integer(nParam))
    return(ans)
}

rLSgetParamMacroID <- function(env,szParam){

    ans <- .Call("rcLSgetParamMacroID", PACKAGE = "rLindo", 
                 env,
                 as.character(szParam))
    return(ans)
}
    
#*************************************************************#
# Model Loading Routines (19)                                 #
#*************************************************************#
rLSloadLPData <- function(model,
                          nCons,
                          nVars,
                          nObjSense,
                          dObjConst,
                          padC,
                          padB,
                          pszConTypes,
                          nAnnz,
                          paiAcols,
                          panAcols = NULL,
                          padAcoef,
                          paiArows,
                          padL = NULL,
                          padU = NULL)
{

    if (is.null(panAcols)) 
    {
        rpanAcols <- as.null(panAcols)
    }
    else 
    {
        rpanAcols <- as.integer(panAcols)
    }
    if (is.null(padL)) 
    {
        rpadL<- as.null(padL)
    }
    else 
    {
        rpadL <- as.numeric(padL)
    }
    if (is.null(padU)) 
    {
        rpadU <- as.null(padU)
    }
    else 
    {
        rpadU <- as.numeric(padU)
    }
    ans <- .Call("rcLSloadLPData", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCons),
                 as.integer(nVars),
                 as.integer(nObjSense),
                 as.numeric(dObjConst),
                 as.numeric(padC),
                 as.numeric(padB),
                 as.character(pszConTypes),
                 as.integer(nAnnz),
                 as.integer(paiAcols),
                 rpanAcols,
                 as.numeric(padAcoef),
                 as.integer(paiArows),
                 rpadL,
                 rpadU)
    return(ans)
}

rLSloadQCData <- function(model,
                          nQCnnz,
                          paiQCrows,
                          paiQCcols1,
                          paiQCcols2,
                          padQCcoef)                          
{

    ans <- .Call("rcLSloadQCData", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQCnnz),
                 as.integer(paiQCrows),
                 as.integer(paiQCcols1),
                 as.integer(paiQCcols2),
                 as.numeric(padQCcoef))         
    return(ans)
}

rLSloadConeData <- function(model,
                            nCone,
                            pszConeTypes,
                            paiConebegcone,
                            paiConecols)                          
{

    ans <- .Call("rcLSloadConeData", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCone),
                 as.character(pszConeTypes),
                 as.integer(paiConebegcone),
                 as.integer(paiConecols))         
    return(ans)
}

rLSloadSETSData <- function(model,
                            nSETS,
                            pszSETStype,
                            paiCARDnum,
                            paiSETSbegcol,
                            paiSETScols)                            
{

    ans <- .Call("rcLSloadSETSData", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSETS),
                 as.character(pszSETStype),
                 as.integer(paiCARDnum),    
                 as.integer(paiSETSbegcol),
                 as.integer(paiSETScols))         
    return(ans)
}

rLSloadSemiContData <- function(model,
                                nSCVars,
                                paiVars,
                                padL,
                                padU)                          
{

    ans <- .Call("rcLSloadSemiContData", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSCVars),
                 as.integer(paiVars),
                 as.numeric(padL),
                 as.numeric(padU))         
    return(ans)
}

rLSloadVarType <- function(model,
                           spszVarTypes)                          
{

    ans <- .Call("rcLSloadVarType", PACKAGE = "rLindo", 
                 model,
                 as.character(spszVarTypes))         
    return(ans)
}

rLSloadNameData <- function(model,
                            pszTitle = NULL,
                            pszObjName = NULL,
                            pszRhsName = NULL,
                            pszRngName = NULL,
                            pszBndname = NULL,
                            paszConNames = NULL,
                            paszVarNames = NULL,
                            paszConeNames = NULL)                          
{
    if (is.null(pszTitle)) 
    {
        rpszTitle <- as.null(pszTitle)
    }
    else 
    {
        rpszTitle <- as.character(pszTitle)
    }
    if (is.null(pszObjName)) 
    {
        rpszObjName <- as.null(pszObjName)
    }
    else 
    {
        rpszObjName <- as.character(pszObjName)
    }
    if (is.null(pszRhsName)) 
    {
        rpszRhsName <- as.null(pszRhsName)
    }
    else 
    {
        rpszRhsName <- as.character(pszRhsName)
    }
    if (is.null(pszRngName)) 
    {
        rpszRngName <- as.null(pszRngName)
    }
    else 
    {
        rpszRngName <- as.character(pszRngName)
    }
    if (is.null(pszBndname)) 
    {
        rpszBndname <- as.null(pszBndname)
    }
    else 
    {
        rpszBndname <- as.character(pszBndname)
    }
    if (is.null(paszConNames)) 
    {
        rpaszConNames <- as.null(paszConNames)
    }
    else 
    {
        rpaszConNames <- as.character(paszConNames)
    }
    if (is.null(paszVarNames)) 
    {
        rpaszVarNames <- as.null(paszVarNames)
    }
    else 
    {
        rpaszVarNames <- as.character(paszVarNames)
    }
    if (is.null(paszConeNames)) 
    {
        rpaszConeNames <- as.null(paszConeNames)
    }
    else 
    {
        rpaszConeNames <- as.character(paszConeNames)
    }
    ans <- .Call("rcLSloadNameData", PACKAGE = "rLindo", 
                 model,
                 rpszTitle,
                 rpszObjName,
                 rpszRhsName,
                 rpszRngName,
                 rpszBndname,
                 rpaszConNames,
                 rpaszVarNames,
                 rpaszConeNames)         
    return(ans)
}

rLSloadNLPData <- function(model,
                           paiNLPcols,
                           panNLPcols,
                           padNLPcoef = NULL,
                           paiNLProws,
                           nNLPobj,
                           paiNLPobj,
                           padNLPobj = NULL)                          
{
    if (is.null(padNLPcoef)) 
    {
        rpadNLPcoef <- as.null(padNLPcoef)
    }
    else 
    {
        rpadNLPcoef <- as.numeric(padNLPcoef)
    }
    if (is.null(padNLPobj)) 
    {
        rpadNLPobj <- as.null(padNLPobj)
    }
    else 
    {
        rpadNLPobj <- as.character(padNLPobj)
    } 

    ans <- .Call("rcLSloadNLPData", PACKAGE = "rLindo", 
                 model,
                 as.integer(paiNLPcols),
                 as.integer(panNLPcols),
                 rpadNLPcoef,
                 as.integer(paiNLProws),
                 as.integer(nNLPobj),
                 as.integer(paiNLPobj),
                 rpadNLPobj)         
    return(ans)
}

rLSloadInstruct <- function(model,
                            nCons,
                            nObjs,
                            nVars,
                            nNumbers,
                            panObjSense,
                            pszConType,
                            pszVarType = NULL,
                            panInstruct,
                            nInstruct,
                            paiVars = NULL,
                            padNumVal,
                            padVarVal,
                            paiObjBeg,
                            panObjLen,
                            paiConBeg,
                            panConLen,
                            padLB = NULL,
                            padUB = NULL)                          
{
    if (is.null(pszVarType)) 
    {
        rpszVarType <- as.null(pszVarType)
    }
    else 
    {
        rpszVarType <- as.character(pszVarType)
    }
    if (is.null(paiVars)) 
    {
        rpaiVars <- as.null(paiVars)
    }
    else 
    {
        rpaiVars <- as.integer(paiVars)
    }
    if (is.null(padLB)) 
    {
        rpadLB <- as.null(padLB)
    }
    else 
    {
        rpadLB <- as.numeric(padLB)
    }
    if (is.null(padUB)) 
    {
        rpadUB <- as.null(padUB)
    }
    else 
    {
        rpadUB <- as.numeric(padUB)
    } 

    ans <- .Call("rcLSloadInstruct", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCons),
                 as.integer(nObjs),
                 as.integer(nVars),
                 as.integer(nNumbers),
                 as.integer(panObjSense),
                 as.character(pszConType),
                 rpszVarType,
                 as.integer(panInstruct),
                 as.integer(nInstruct),
                 rpaiVars,
                 as.numeric(padNumVal),
                 as.numeric(padVarVal),
                 as.integer(paiObjBeg),
                 as.integer(panObjLen),
                 as.integer(paiConBeg),
                 as.integer(panConLen),
                 rpadLB,
                 rpadUB)         
    return(ans)
}

rLSaddInstruct <- function(model,
                           nCons,
                           nObjs,
                           nVars,
                           nNumbers,
                           panObjSense,
                           pszConType,
                           pszVarType = NULL,
                           panInstruct,
                           nInstruct,
                           paiCons = NULL,
                           padNumVal,
                           padVarVal,
                           paiObjBeg,
                           panObjLen,
                           paiConBeg,
                           panConLen,
                           padLB = NULL,
                           padUB = NULL)                          
{
    if (is.null(pszVarType)) 
    {
        rpszVarType <- as.null(pszVarType)
    }
    else 
    {
        rpszVarType <- as.character(pszVarType)
    }
    if (is.null(paiCons)) 
    {
        rpaiCons <- as.null(paiCons)
    }
    else 
    {
        rpaiCons <- as.integer(paiCons)
    }
    if (is.null(padLB)) 
    {
        rpadLB <- as.null(padLB)
    }
    else 
    {
        rpadLB <- as.numeric(padLB)
    }
    if (is.null(padUB)) 
    {
        rpadUB <- as.null(padUB)
    }
    else 
    {
        rpadUB <- as.numeric(padUB)
    } 

    ans <- .Call("rcLSaddInstruct", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCons),
                 as.integer(nObjs),
                 as.integer(nVars),
                 as.integer(nNumbers),
                 as.integer(panObjSense),
                 as.character(pszConType),
                 rpszVarType,
                 as.integer(panInstruct),
                 as.integer(nInstruct),
                 rpaiCons,
                 as.numeric(padNumVal),
                 as.numeric(padVarVal),
                 as.integer(paiObjBeg),
                 as.integer(panObjLen),
                 as.integer(paiConBeg),
                 as.integer(panConLen),
                 rpadLB,
                 rpadUB)         
    return(ans)
}

rLSloadStringData <- function(model,
                              nStrings,
                              paszStringData)                          
{

    ans <- .Call("rcLSloadStringData", PACKAGE = "rLindo", 
                 model,
                 as.integer(nStrings),
                 as.character(paszStringData))         
    return(ans)
}

rLSloadString <- function(model,
                          pszString)                          
{

    ans <- .Call("rcLSloadString", PACKAGE = "rLindo", 
                 model,
                 as.character(pszString))         
    return(ans)
}

rLSdeleteStringData <- function(model)                          
{

    ans <- .Call("rcLSdeleteStringData", PACKAGE = "rLindo", 
                 model)         
    return(ans)
}

rLSdeleteString <- function(model)                          
{

    ans <- .Call("rcLSdeleteString", PACKAGE = "rLindo", 
                 model)         
    return(ans)
}

rLSgetStringValue <- function(model,
                              iString)                          
{

    ans <- .Call("rcLSgetStringValue", PACKAGE = "rLindo", 
                 model,
                 as.integer(iString))         
    return(ans)
}

rLSgetConstraintProperty <- function(model,
                                     ndxCons)                          
{

    ans <- .Call("rcLSgetConstraintProperty", PACKAGE = "rLindo", 
                 model,
                 as.integer(ndxCons))         
    return(ans)
}

rLSsetConstraintProperty <- function(model,
                                     ndxCons,
                                     nConptype)                          
{

    ans <- .Call("rcLSsetConstraintProperty", PACKAGE = "rLindo", 
                 model,
                 as.integer(ndxCons),
                 as.integer(nConptype))         
    return(ans)
}

rLSloadMultiStartSolution <- function(model,
                                      nIndex)                          
{

    ans <- .Call("rcLSloadMultiStartSolution", PACKAGE = "rLindo", 
                 model,
                 as.integer(nIndex))         
    return(ans)
}

rLSloadGASolution <- function(model,
                              nIndex)                          
{

    ans <- .Call("rcLSloadGASolution", PACKAGE = "rLindo", 
                 model,
                 as.integer(nIndex))         
    return(ans)
}

#**************************************************************#
# Solver Initialization Routines (9)                           #
#**************************************************************#
rLSloadBasis <- function(model,
                         panCstatus,
                         panRstatus)                          
{

    ans <- .Call("rcLSloadBasis", PACKAGE = "rLindo", 
                 model,
                 as.integer(panCstatus),
                 as.integer(panRstatus))         
    return(ans)
}

rLSloadVarPriorities <- function(model,
                                 panCprior)                          
{

    ans <- .Call("rcLSloadVarPriorities", PACKAGE = "rLindo", 
                 model,
                 as.integer(panCprior))         
    return(ans)
}

rLSreadVarPriorities <- function(model,
                                 pszFname)                          
{

    ans <- .Call("rcLSreadVarPriorities", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))         
    return(ans)
}

rLSloadVarStartPoint <- function(model,
                                 padPrimal)                          
{

    ans <- .Call("rcLSloadVarStartPoint", PACKAGE = "rLindo", 
                 model,
                 as.numeric(padPrimal))         
    return(ans)
}

rLSloadVarStartPointPartial <- function(model,
                                        nCols,
                                        paiCols,
                                        padPrimal)                          
{

    ans <- .Call("rcLSloadVarStartPointPartial", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCols),
                 as.integer(paiCols),
                 as.numeric(padPrimal))         
    return(ans)
}

rLSloadMIPVarStartPoint <- function(model,
                                    padPrimal)                          
{

    ans <- .Call("rcLSloadMIPVarStartPoint", PACKAGE = "rLindo", 
                 model,
                 as.numeric(padPrimal))         
    return(ans)
}

rLSloadMIPVarStartPointPartial <- function(model,
                                           nCols,
                                           paiCols,
                                           paiPrimal)                          
{

    ans <- .Call("rcLSloadMIPVarStartPointPartial", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCols),
                 as.integer(paiCols),
                 as.integer(paiPrimal))         
    return(ans)
}

rLSreadVarStartPoint <- function(model,
                                 pszFname)                          
{

    ans <- .Call("rcLSreadVarStartPoint", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFname))         
    return(ans)
}

rLSloadBlockStructure <- function(model,
                                  nBlock,
								  panRblock,
								  panCblock,
								  nType)                          
{

    ans <- .Call("rcLSloadBlockStructure", PACKAGE = "rLindo", 
                 model,
                 as.integer(nBlock),
                 as.integer(panRblock),
                 as.integer(panCblock),
                 as.integer(nType))         
    return(ans)
}

#**************************************************************#
# Optimization Routines (6)                                    #
#**************************************************************#
rLSoptimize <- function(model,
                        nMethod)
{

    ans <- .Call("rcLSoptimize", PACKAGE = "rLindo", 
                 model,
                 as.integer(nMethod))
    return(ans)
}

rLSsolveMIP <- function(model)
{
    tryCatch
    (
         ans <- .Call("rcLSsolveMIP", PACKAGE = "rLindo", 
                      model)
     )

     return(ans)
}

rLSsolveGOP <- function(model)
{

    ans <- .Call("rcLSsolveGOP", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSoptimizeQP <- function(model)
{

    ans <- .Call("rcLSoptimizeQP", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLScheckConvexity <- function(model)
{

    ans <- .Call("rcLScheckConvexity", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSsolveSBD <- function(model,
                        nStages,
					    panRowStage,
					    panColStage)
{

    ans <- .Call("rcLSsolveSBD", PACKAGE = "rLindo", 
                 model,
                 as.integer(nStages),
                 as.integer(panRowStage),
                 as.integer(panColStage))
    return(ans)
}

#**************************************************************#
# Solution Query Routines (15)                                 #
#**************************************************************#
rLSgetIInfo <- function(model,
                        nQuery)
{

    ans <- .Call("rcLSgetIInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery))
    return(ans)
}

rLSgetDInfo <- function(model,
                        nQuery)
{

    ans <- .Call("rcLSgetDInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery))
    return(ans)
}

rLSgetPrimalSolution <- function(model)
{

    ans <- .Call("rcLSgetPrimalSolution", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetDualSolution <- function(model)
{

    ans <- .Call("rcLSgetDualSolution", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetReducedCosts <- function(model)
{

    ans <- .Call("rcLSgetReducedCosts", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetReducedCostsCone <- function(model)
{

    ans <- .Call("rcLSgetReducedCostsCone", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetSlacks <- function(model)
{

    ans <- .Call("rcLSgetSlacks", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetBasis <- function(model)
{

    ans <- .Call("rcLSgetBasis", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetSolution <- function(model,
                           nWhich)
{

    ans <- .Call("rcLSgetSolution", PACKAGE = "rLindo", 
                 model,
                 as.integer(nWhich))
    return(ans)
}

rLSgetMIPPrimalSolution <- function(model)
{

    ans <- .Call("rcLSgetMIPPrimalSolution", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetMIPDualSolution <- function(model)
{

    ans <- .Call("rcLSgetMIPDualSolution", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetMIPReducedCosts <- function(model)
{

    ans <- .Call("rcLSgetMIPReducedCosts", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetMIPSlacks <- function(model)
{

    ans <- .Call("rcLSgetMIPSlacks", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetMIPBasis <- function(model)
{

    ans <- .Call("rcLSgetMIPBasis", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetNextBestMIPSol <- function(model)
{

    ans <- .Call("rcLSgetNextBestMIPSol", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

#**************************************************************#
#    Model Query Routines (29)                                 #
#**************************************************************#
rLSgetLPData <- function(model)
{

    ans <- .Call("rcLSgetLPData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetQCData <- function(model)
{

    ans <- .Call("rcLSgetQCData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetQCDatai <- function(model,
                          iCon)
{

    ans <- .Call("rcLSgetQCDatai", PACKAGE = "rLindo", 
                 model,
                 as.integer(iCon))
    return(ans)
}

rLSgetVarType <- function(model)
{

    ans <- .Call("rcLSgetVarType", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetVarStartPoint <- function(model)
{

    ans <- .Call("rcLSgetVarStartPoint", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetVarStartPointPartial <- function(model)
{

    ans <- .Call("rcLSgetVarStartPointPartial", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetMIPVarStartPointPartial <- function(model)
{

    ans <- .Call("rcLSgetMIPVarStartPointPartial", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetMIPVarStartPoint <- function(model)
{

    ans <- .Call("rcLSgetMIPVarStartPoint", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetSETSData <- function(model)
{

    ans <- .Call("rcLSgetSETSData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetSETSDatai <- function(model,
                            iSet)
{

    ans <- .Call("rcLSgetSETSDatai", PACKAGE = "rLindo", 
                 model,
                 as.integer(iSet))
    return(ans)
}

rLSgetSemiContData <- function(model)
{

    ans <- .Call("rcLSgetSemiContData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetLPVariableDataj <- function(model,
                                  iVar)
{

    ans <- .Call("rcLSgetLPVariableDataj", PACKAGE = "rLindo", 
                 model,
                 as.integer(iVar))
    return(ans)
}

rLSgetVariableNamej <- function(model,
                                iVar)
{

    ans <- .Call("rcLSgetVariableNamej", PACKAGE = "rLindo", 
                 model,
                 as.integer(iVar))
    return(ans)
}

rLSgetVariableIndex <- function(model,
                                pszVarName)
{

    ans <- .Call("rcLSgetVariableIndex", PACKAGE = "rLindo", 
                 model,
                 as.character(pszVarName))
    return(ans)
}

rLSgetConstraintNamei <- function(model,
                                  iCon)
{

    ans <- .Call("rcLSgetConstraintNamei", PACKAGE = "rLindo", 
                 model,
                 as.integer(iCon))
    return(ans)
}

rLSgetConstraintIndex <- function(model,
                                  pszConName)
{

    ans <- .Call("rcLSgetConstraintIndex", PACKAGE = "rLindo", 
                 model,
                 as.character(pszConName))
    return(ans)
}

rLSgetConstraintDatai <- function(model,
                                  iCon)
{

    ans <- .Call("rcLSgetConstraintDatai", PACKAGE = "rLindo", 
                 model,
                 as.integer(iCon))
    return(ans)
}

rLSgetLPConstraintDatai <- function(model,
                                    iCon)
{

    ans <- .Call("rLSgetLPConstraintDatai", PACKAGE = "rLindo", 
                 model,
                 as.integer(iCon))
    return(ans)
}

rLSgetConeNamei <- function(model,
                            iCone)
{

    ans <- .Call("rcLSgetConeNamei", PACKAGE = "rLindo", 
                 model,
                 as.integer(iCone))
    return(ans)
}

rLSgetConeIndex <- function(model,
                            pszConeName)
{

    ans <- .Call("rcLSgetConeIndex", PACKAGE = "rLindo", 
                 model,
                 as.character(pszConeName))
    return(ans)
}

rLSgetConeDatai <- function(model,
                            iCone)
{

    ans <- .Call("rcLSgetConeDatai", PACKAGE = "rLindo", 
                 model,
                 as.integer(iCone))
    return(ans)
}

rLSgetNLPData <- function(model)
{

    ans <- .Call("rcLSgetNLPData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetNLPConstraintDatai <- function(model,
                                     iCon)
{

    ans <- .Call("rcLSgetNLPConstraintDatai", PACKAGE = "rLindo", 
                 model,
                 as.integer(iCon))
    return(ans)
}

rLSgetNLPVariableDataj <- function(model,
                                   iVar)
{

    ans <- .Call("rcLSgetNLPVariableDataj", PACKAGE = "rLindo", 
                 model,
                 as.integer(iVar))
    return(ans)
}

rLSgetNLPObjectiveData <- function(model)
{

    ans <- .Call("rcLSgetNLPObjectiveData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetDualModel <- function(model,
                            dualmodel)
{

    ans <- .Call("rcLSgetDualModel", PACKAGE = "rLindo", 
                 model,
                 dualmodel)
    return(ans)
}

rLScalinfeasMIPsolution <- function(model,
                                    padPrimalMipsol = NULL)
{
    if (is.null(padPrimalMipsol)) 
    {
        rpadPrimalMipsol <- as.null(padPrimalMipsol)
    }
    else 
    {
        rpadPrimalMipsol <- as.numeric(padPrimalMipsol)
    }

    ans <- .Call("rcLScalinfeasMIPsolution", PACKAGE = "rLindo", 
                 model,
                 rpadPrimalMipsol)
    return(ans)
}

rLSgetRoundMIPsolution <- function(model,
                                   padPrimal = NULL,
                                   iUseOpti)
{
	if (is.null(padPrimal)) 
    {
        rpadPrimal <- as.null(padPrimal)
    }
    else 
    {
        rpadPrimal <- as.numeric(padPrimal)
    }
    
    ans <- .Call("rcLSgetRoundMIPsolution", PACKAGE = "rLindo", 
                 model,
                 rpadPrimal,
                 as.integer(iUseOpti))
    return(ans)
}

rLSgetRangeData <- function(model)
{

    ans <- .Call("rcLSgetRangeData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

#**************************************************************#
# Model Modification Routines (25)                             #
#**************************************************************#
rLSaddConstraints <- function(model,
                              nNumaddcons,
                              pszConTypes,
                              paszConNames = NULL,
                              paiArows,
                              padAcoef,
                              paiAcols,
                              padB)
{
    if (is.null(paszConNames)) 
    {
        rpaszConNames <- as.null(paszConNames)
    }
    else 
    {
        rpaszConNames <- as.character(paszConNames)
    }

    ans <- .Call("rcLSaddConstraints", PACKAGE = "rLindo", 
                 model,
                 as.integer(nNumaddcons),
                 as.character(pszConTypes),
                 rpaszConNames,
                 as.integer(paiArows),
                 as.numeric(padAcoef),
                 as.integer(paiAcols),
                 as.numeric(padB))
    return(ans)
}

rLSaddVariables <- function(model,
                            nNumaddvars,
                            pszVarTypes,
                            paszVarNames = NULL,
                            paiAcols,
                            panAcols = NULL,
                            padAcoef,
                            paiArows,
                            padC,
                            padL = NULL,
                            padU = NULL)
{
    if (is.null(paszVarNames)) 
    {
        rpaszVarNames <- as.null(paszVarNames)
    }
    else 
    {
        rpaszVarNames <- as.character(paszVarNames)
    }

    if (is.null(panAcols)) 
    {
        rpanAcols <- as.null(panAcols)
    }
    else 
    {
        rpanAcols <- as.integer(panAcols)
    }

    if (is.null(padL)) 
    {
        rpadL <- as.null(padL)
    }
    else 
    {
        rpadL <- as.numeric(padL)
    }

    if (is.null(padU)) 
    {
        rpadU <- as.null(padU)
    }
    else 
    {
        rpadU <- as.numeric(padU)
    }

    ans <- .Call("rcLSaddVariables", PACKAGE = "rLindo", 
                 model,
                 as.integer(nNumaddvars),
                 as.character(pszVarTypes),
                 rpaszVarNames,
                 as.integer(paiAcols),
                 rpanAcols,
                 as.numeric(padAcoef),
                 as.integer(paiArows),
                 as.numeric(padC),
                 rpadL,
                 rpadU)
    return(ans)
}

rLSaddCones <- function(model,
                        nCone,
                        pszConeTypes,
                        paszConenames = NULL,
                        paiConebegcol,
                        paiConecols)
{
    if (is.null(paszConenames)) 
    {
        rpaszConenames <- as.null(paszConenames)
    }
    else 
    {
        rpaszConenames <- as.character(paszConenames)
    }

    ans <- .Call("rcLSaddCones", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCone),
                 as.character(pszConeTypes),
                 rpaszConenames,
                 as.integer(paiConebegcol),
                 as.integer(paiConecols))
    return(ans)
}

rLSaddSETS <- function(model,
                       nSETS,
                       pszSETStype,
                       paiCARDnum,
                       paiSETSbegcol,
                       paiSETScols)
{
    ans <- .Call("rcLSaddSETS", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSETS),
                 as.character(pszSETStype),
                 as.integer(paiCARDnum),
                 as.integer(paiSETSbegcol),
                 as.integer(paiSETScols))
    return(ans)
}

rLSaddQCterms <- function(model,
                          nQCnonzeros,
                          paiQCconndx,
                          paiQCvarndx1,
                          paiQCvarndx2,
                          padQCcoef)
{
    ans <- .Call("rcLSaddQCterms", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQCnonzeros),
                 as.integer(paiQCconndx),
                 as.integer(paiQCvarndx1),
                 as.integer(paiQCvarndx2),
                 as.numeric(padQCcoef))
    return(ans)
}

rLSdeleteConstraints <- function(model,
                                 nCons,
                                 paiCons)
{
    ans <- .Call("rcLSdeleteConstraints", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCons),
                 as.integer(paiCons))
    return(ans)
}

rLSdeleteCones <- function(model,
                           nCones,
                           paiCones)
{
    ans <- .Call("rcLSdeleteCones", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCones),
                 as.integer(paiCones))
    return(ans)
}

rLSdeleteSETS <- function(model,
                          nSETS,
                          paiSETS)
{
    ans <- .Call("rcLSdeleteSETS", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSETS),
                 as.integer(paiSETS))
    return(ans)
}

rLSdeleteSemiContVars <- function(model,
                                  nSCVars,
                                  paiSCVars)
{
    ans <- .Call("rcLSdeleteSemiContVars", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSCVars),
                 as.integer(paiSCVars))
    return(ans)
}

rLSdeleteVariables <- function(model,
                               nVars,
                               paiVars)
{
    ans <- .Call("rcLSdeleteVariables", PACKAGE = "rLindo", 
                 model,
                 as.integer(nVars),
                 as.integer(paiVars))
    return(ans)
}

rLSdeleteQCterms <- function(model,
                             nCons,
                             paiCons)
{
    ans <- .Call("rcLSdeleteQCterms", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCons),
                 as.integer(paiCons))
    return(ans)
}

rLSdeleteAj <- function(model,
                        iVar1,
                        nRows,
                        paiRows)
{
    ans <- .Call("rcLSdeleteAj", PACKAGE = "rLindo", 
                 model,
                 as.integer(iVar1),
                 as.integer(nRows),
                 as.integer(paiRows))
    return(ans)
}

rLSmodifyLowerBounds <- function(model,
                                 nVars,
                                 paiVars,
                                 padL)
{
    ans <- .Call("rcLSmodifyLowerBounds", PACKAGE = "rLindo", 
                 model,
                 as.integer(nVars),
                 as.integer(paiVars),
                 as.numeric(padL))
    return(ans)
}

rLSmodifyUpperBounds <- function(model,
                                 nVars,
                                 paiVars,
                                 padU)
{
    ans <- .Call("rcLSmodifyLowerBounds", PACKAGE = "rLindo", 
                 model,
                 as.integer(nVars),
                 as.integer(paiVars),
                 as.numeric(padU))
    return(ans)
}

rLSmodifyRHS <- function(model,
                         nCons,
                         paiCons,
                         padB)
{
    ans <- .Call("rcLSmodifyRHS", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCons),
                 as.integer(paiCons),
                 as.numeric(padB))
    return(ans)
}

rLSmodifyObjective <- function(model,
                               nVars,
                               paiVars,
                               padC)
{
    ans <- .Call("rcLSmodifyObjective", PACKAGE = "rLindo", 
                 model,
                 as.integer(nVars),
                 as.integer(paiVars),
                 as.numeric(padC))
    return(ans)
}

rLSmodifyAj <- function(model,
                        iVar1,
                        nRows,
                        paiRows,
                        padAj)
{
    ans <- .Call("rcLSmodifyAj", PACKAGE = "rLindo", 
                 model,
                 as.integer(iVar1),
                 as.integer(nRows),
                 as.integer(paiRows),
                 as.numeric(padAj))
    return(ans)
}

rLSmodifyCone <- function(model,
                          cConeType,
                          iConeNum,
                          iConeNnz,
                          paiConeCols)
{
    ans <- .Call("rcLSmodifyCone", PACKAGE = "rLindo", 
                 model,
                 as.character(cConeType),
                 as.integer(iConeNum),
                 as.integer(iConeNnz),
                 as.integer(paiConeCols))
    return(ans)
}

rLSmodifySET <- function(model,
                         cSETtype,
                         iSETnum,
                         iSETnnz,
                         paiSETcols)
{
    ans <- .Call("rcLSmodifySET", PACKAGE = "rLindo", 
                 model,
                 as.character(cSETtype),
                 as.integer(iSETnum),
                 as.integer(iSETnnz),
                 as.integer(paiSETcols))
    return(ans)
}

rLSmodifySemiContVars <- function(model,
                                  nSCVars,
                                  paiSCVars,
                                  padL,
                                  padU)
{
    ans <- .Call("rcLSmodifySemiContVars", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSCVars),
                 as.integer(paiSCVars),
                 as.numeric(padL),
                 as.numeric(padU))
    return(ans)
}

rLSmodifyConstraintType <- function(model,
                                    nCons,
                                    paiCons,
                                    pszConTypes)
{
    ans <- .Call("rcLSmodifyConstraintType", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCons),
                 as.integer(paiCons),
                 as.character(pszConTypes))
    return(ans)
}

rLSmodifyVariableType <- function(model,
                                  nVars,
                                  paiVars,
                                  pszVarTypes)
{
    ans <- .Call("rcLSmodifyVariableType", PACKAGE = "rLindo", 
                 model,
                 as.integer(nVars),
                 as.integer(paiVars),
                 as.character(pszVarTypes))
    return(ans)
}

rLSaddNLPAj <- function(model,
                        iVar1,
                        nRows,
                        paiRows,
                        padAj)
{
    ans <- .Call("rcLSaddNLPAj", PACKAGE = "rLindo", 
                 model,
                 as.integer(iVar1),
                 as.integer(nRows),
                 as.integer(paiRows),
                 as.numeric(padAj))
    return(ans)
}

rLSaddNLPobj <- function(model,
                         nCols,
                         paiCols,
                         padColj)
{
    ans <- .Call("rcLSaddNLPobj", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCols),
                 as.integer(paiCols),
                 as.numeric(padColj))
    return(ans)
}

rLSdeleteNLPobj <- function(model,
                            nCols,
                            paiCols)
{
    ans <- .Call("rcLSdeleteNLPobj", PACKAGE = "rLindo", 
                 model,
                 as.integer(nCols),
                 as.integer(paiCols))
    return(ans)
}

#**************************************************************#
# Model & Solution Analysis Routines (10)                      #
#**************************************************************#
rLSgetConstraintRanges <- function(model)
{
    ans <- .Call("rcLSgetConstraintRanges", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetObjectiveRanges <- function(model)
{
    ans <- .Call("rcLSgetObjectiveRanges", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetBoundRanges <- function(model)
{
    ans <- .Call("rcLSgetBoundRanges", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetBestBounds <- function(model)
{
    ans <- .Call("rcLSgetBestBounds", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSfindIIS <- function(model,
                       nLevel)
{
    ans <- .Call("rcLSfindIIS", PACKAGE = "rLindo", 
                 model,
                 as.integer(nLevel))
    return(ans)
}

rLSfindIUS <- function(model,
                       nLevel)
{
    ans <- .Call("rcLSfindIUS", PACKAGE = "rLindo", 
                 model,
                 as.integer(nLevel))
    return(ans)
}

rLSfindBlockStructure <- function(model,
                                  nBlock,
                                  nType)
{
    ans <- .Call("rcLSfindBlockStructure", PACKAGE = "rLindo", 
                 model,
                 as.integer(nBlock),
                 as.integer(nType))
    return(ans)
}

rLSgetIIS <- function(model)
{
    ans <- .Call("rcLSgetIIS", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetIUS <- function(model)
{
    ans <- .Call("rcLSgetIUS", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetBlockStructure <- function(model)
{
    ans <- .Call("rcLSgetBlockStructure", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

#**************************************************************#
# Memory Related Routines(9)                                   #
#**************************************************************#
rLSfreeSolverMemory <- function(model)
{
    ans <- .Call("rcLSfreeSolverMemory", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSfreeHashMemory <- function(model)
{
    ans <- .Call("rcLSfreeHashMemory", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSfreeSolutionMemory <- function(model)
{
    ans <- .Call("rcLSfreeSolutionMemory", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSfreeMIPSolutionMemory <- function(model)
{
    ans <- .Call("rcLSfreeMIPSolutionMemory", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSfreeGOPSolutionMemory <- function(model)
{
    ans <- .Call("rcLSfreeGOPSolutionMemory", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSsetProbAllocSizes <- function(model,
                                 n_vars_alloc,
                                 n_cons_alloc,
                                 n_QC_alloc,
                                 n_Annz_alloc,
                                 n_Qnnz_alloc,
                                 n_NLPnnz_alloc)
{
    ans <- .Call("rcLSsetProbAllocSizes", PACKAGE = "rLindo", 
                 model,
                 as.integer(n_vars_alloc),
                 as.integer(n_cons_alloc),
                 as.integer(n_QC_alloc),
                 as.integer(n_Annz_alloc),
                 as.integer(n_Qnnz_alloc),
                 as.integer(n_NLPnnz_alloc))
    return(ans)
}

rLSsetProbNameAllocSizes <- function(model,
                                     n_varname_alloc,
                                     n_rowname_alloc)
{
    ans <- .Call("rcLSsetProbNameAllocSizes", PACKAGE = "rLindo", 
                 model,
                 as.integer(n_varname_alloc),
                 as.integer(n_rowname_alloc))
    return(ans)
}

rLSaddEmptySpacesAcolumns <- function(model,
                                      paiColnnz)
{
    ans <- .Call("rcLSaddEmptySpacesAcolumns", PACKAGE = "rLindo", 
                 model,
                 as.integer(paiColnnz))
    return(ans)
}

rLSaddEmptySpacesNLPAcolumns <- function(model,
                                         paiColnnz)
{
    ans <- .Call("rcLSaddEmptySpacesNLPAcolumns", PACKAGE = "rLindo", 
                 model,
                 as.integer(paiColnnz))
    return(ans)
}

#**************************************************************#
# Stochastic Programming Interface (88)                        #
#**************************************************************#
rLSwriteDeteqMPSFile <- function(model,
                                 pszFilename,
                                 nFormat,
                                 iType)
{
    ans <- .Call("rcLSwriteDeteqMPSFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFilename),
                 as.integer(nFormat),
                 as.integer(iType))
    return(ans)
}

rLSwriteDeteqLINDOFile <- function(model,
                                   pszFilename,
                                   iType)
{
    ans <- .Call("rcLSwriteDeteqLINDOFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszFilename),
                 as.integer(iType))
    return(ans)
}

rLSwriteSMPSFile <- function(model,
                             pszCorefile,
                             pszTimefile,
                             pszStocfile,
                             nMPStype)
{
    ans <- .Call("rcLSwriteSMPSFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszCorefile),
                 as.character(pszTimefile),
                 as.character(pszStocfile),
                 as.integer(nMPStype))
    return(ans)
}

rLSreadSMPSFile <- function(model,
                            pszCorefile,
                            pszTimefile,
                            pszStocfile,
                            nMPStype)
{
    ans <- .Call("rcLSreadSMPSFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszCorefile),
                 as.character(pszTimefile),
                 as.character(pszStocfile),
                 as.integer(nMPStype))
    return(ans)
}

rLSwriteSMPIFile <- function(model,
                             pszCorefile,
                             pszTimefile,
                             pszStocfile)
{
    ans <- .Call("rcLSwriteSMPIFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszCorefile),
                 as.character(pszTimefile),
                 as.character(pszStocfile))
    return(ans)
}

rLSreadSMPIFile <- function(model,
                            pszCorefile,
                            pszTimefile,
                            pszStocfile)
{
    ans <- .Call("rcLSreadSMPIFile", PACKAGE = "rLindo", 
                 model,
                 as.character(pszCorefile),
                 as.character(pszTimefile),
                 as.character(pszStocfile))
    return(ans)
}

rLSwriteScenarioSolutionFile <- function(model,
                                         jScenario,
                                         pszFname)
{
    ans <- .Call("rcLSwriteScenarioSolutionFile", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.character(pszFname))
    return(ans)
}

rLSwriteNodeSolutionFile <- function(model,
                                     jScenario,
                                     iStage,
                                     pszFname)
{
    ans <- .Call("rcLSwriteNodeSolutionFile", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.integer(iStage),
                 as.character(pszFname))
    return(ans)
}

rLSwriteScenarioMPIFile <- function(model,
                                    jScenario,
                                    pszFname)
{
    ans <- .Call("rcLSwriteScenarioMPIFile", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.character(pszFname))
    return(ans)
}

rLSwriteScenarioMPSFile <- function(model,
                                    jScenario,
                                    pszFname,
                                    nFormat)
{
    ans <- .Call("rcLSwriteScenarioMPSFile", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.character(pszFname),
                 as.integer(nFormat))
    return(ans)
}

rLSwriteScenarioLINDOFile <- function(model,
                                      jScenario,
                                      pszFname)
{
    ans <- .Call("rcLSwriteScenarioLINDOFile", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.character(pszFname))
    return(ans)
}

rLSsetModelStocDouParameter <- function(model,
                                        iPar,
                                        dVal)
{
    ans <- .Call("rcLSsetModelStocDouParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(iPar),
                 as.numeric(dVal))
    return(ans)
}

rLSgetModelStocDouParameter <- function(model,
                                        iPar)
{
    ans <- .Call("rcLSgetModelStocDouParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(iPar))
    return(ans)
}

rLSsetModelStocIntParameter <- function(model,
                                        iPar,
                                        iVal)
{
    ans <- .Call("rcLSsetModelStocIntParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(iPar),
                 as.integer(iVal))
    return(ans)
}

rLSgetModelStocIntParameter <- function(model,
                                        iPar)
{
    ans <- .Call("rcLSgetModelStocIntParameter", PACKAGE = "rLindo", 
                 model,
                 as.integer(iPar))
    return(ans)
}

rLSgetScenarioIndex <- function(model,
                                pszName)
{
    ans <- .Call("rcLSgetScenarioIndex", PACKAGE = "rLindo", 
                 model,
                 as.character(pszName))
    return(ans)
}

rLSgetStageIndex <- function(model,
                             pszName)
{
    ans <- .Call("rcLSgetStageIndex", PACKAGE = "rLindo", 
                 model,
                 as.character(pszName))
    return(ans)
}

rLSgetStocParIndex <- function(model,
                               pszName)
{
    ans <- .Call("rcLSgetStocParIndex", PACKAGE = "rLindo", 
                 model,
                 as.character(pszName))
    return(ans)
}

rLSgetStocParName <- function(model,
                              nIndex)
{
    ans <- .Call("rcLSgetStocParName", PACKAGE = "rLindo", 
                 model,
                 as.integer(nIndex))
    return(ans)
}

rLSgetScenarioName <- function(model,
                               nIndex)
{
    ans <- .Call("rcLSgetScenarioName", PACKAGE = "rLindo", 
                 model,
                 as.integer(nIndex))
    return(ans)
}

rLSgetStageName <- function(model,
                            nIndex)
{
    ans <- .Call("rcLSgetStageName", PACKAGE = "rLindo", 
                 model,
                 as.integer(nIndex))
    return(ans)
}

rLSgetStocIInfo <- function(model,
                            nQuery,
                            nParam)
{
    ans <- .Call("rcLSgetStocIInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.integer(nParam))
    return(ans)
}

rLSgetStocDInfo <- function(model,
                            nQuery,
                            nParam)
{
    ans <- .Call("rcLSgetStocDInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.integer(nParam))
    return(ans)
}

rLSgetStocSInfo <- function(model,
                            nQuery,
                            nParam)
{
    ans <- .Call("rcLSgetStocDInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.integer(nParam))
    return(ans)
}

rLSgetStocCCPIInfo <- function(model,
                               nQuery,
                               nScenarioIndex,
                               nCPPIndex)
{
    ans <- .Call("rcLSgetStocCCPIInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.integer(nScenarioIndex),
                 as.integer(nCPPIndex))
    return(ans)
}

rLSgetStocCCPDInfo <- function(model,
                               nQuery,
                               nScenarioIndex,
                               nCPPIndex)
{
    ans <- .Call("rcLSgetStocCCPDInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.integer(nScenarioIndex),
                 as.integer(nCPPIndex))
    return(ans)
}

rLSgetStocCCPSInfo <- function(model,
                               nQuery,
                               nScenarioIndex,
                               nCPPIndex)
{
    ans <- .Call("rcLSgetStocCCPSInfo", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.integer(nScenarioIndex),
                 as.integer(nCPPIndex))
    return(ans)
}

rLSloadSampleSizes <- function(model,
                               panSampleSize)
{
    ans <- .Call("rcLSloadSampleSizes", PACKAGE = "rLindo", 
                 model,
                 as.integer(panSampleSize))
    return(ans)
}

rLSloadConstraintStages <- function(model,
                                    panStage)
{
    ans <- .Call("rcLSloadConstraintStages", PACKAGE = "rLindo", 
                 model,
                 as.integer(panStage))
    return(ans)
}

rLSloadVariableStages <- function(model,
                                  panStage)
{
    ans <- .Call("rcLSloadVariableStages", PACKAGE = "rLindo", 
                 model,
                 as.integer(panStage))
    return(ans)
}

rLSloadStageData <- function(model,
                             numStages,
                             panRstage,
                             panCstage)
{
    ans <- .Call("rcLSloadStageData", PACKAGE = "rLindo", 
                 model,
                 as.integer(numStages),
                 as.integer(panRstage),
                 as.integer(panCstage))
    return(ans)
}

rLSloadStocParData <- function(model,
                               panSparStage,
                               padSparValue)
{
    ans <- .Call("rcLSloadStocParData", PACKAGE = "rLindo", 
                 model,
                 as.integer(panSparStage),
                 as.numeric(padSparValue))
    return(ans)
}

rLSloadStocParNames <- function(model,
                                nSvars,
                                paszSVarNames)
{
    ans <- .Call("rcLSloadStocParNames", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSvars),
                 as.character(paszSVarNames))
    return(ans)
}

rLSgetDeteqModel <- function(model,
                             iDeqType)
{
    ans <- .Call("rcLSgetDeteqModel", PACKAGE = "rLindo", 
                 model,
                 as.integer(iDeqType))
    return(ans)
}

rLSaggregateStages <- function(model,
                               panScheme,
                               nLength)
{
    ans <- .Call("rcLSaggregateStages", PACKAGE = "rLindo", 
                 model,
                 as.integer(panScheme),
                 as.integer(nLength))
    return(ans)
}

rLSgetStageAggScheme <- function(model)
{
    ans <- .Call("rcLSgetStageAggScheme", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSdeduceStages <- function(model,
                            nMaxStage,
                            panRowStagesIn,
                            panColStagesIn,
                            panSparStage)
{
    ans <- .Call("rcLSdeduceStages", PACKAGE = "rLindo", 
                 model,
                 as.integer(nMaxStage),
                 as.integer(panRowStagesIn),
                 as.integer(panColStagesIn),
                 as.integer(panSparStage))
    return(ans)
}

rLSsolveSP <- function(model)
{
    ans <- .Call("rcLSsolveSP", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSsolveHS <- function(model,
                       nSearchMethod)
{
    ans <- .Call("rcLSsolveHS", PACKAGE = "rLindo", 
                 model,
                 as.integer(nSearchMethod))
    return(ans)
}

rLSgetScenarioObjective <- function(model,
                                    jScenario)
{
    ans <- .Call("rcLSgetScenarioObjective", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetNodePrimalSolution <- function(model,
                                     jScenario,
                                     iStage)
{
    ans <- .Call("rcLSgetNodePrimalSolution", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.integer(iStage))
    return(ans)
}

rLSgetNodeDualSolution <- function(model,
                                   jScenario,
                                   iStage)
{
    ans <- .Call("rcLSgetNodeDualSolution", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.integer(iStage))
    return(ans)
}

rLSgetNodeReducedCost <- function(model,
                                  jScenario,
                                  iStage)
{
    ans <- .Call("rcLSgetNodeReducedCost", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.integer(iStage))
    return(ans)
}

rLSgetNodeSlacks <- function(model,
                             jScenario,
                             iStage)
{
    ans <- .Call("rcLSgetNodeSlacks", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.integer(iStage))
    return(ans)
}

rLSgetScenarioPrimalSolution <- function(model,
                                         jScenario)
{
    ans <- .Call("rcLSgetScenarioPrimalSolution", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetScenarioReducedCost <- function(model,
                                      jScenario)
{
    ans <- .Call("rcLSgetScenarioReducedCost", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetScenarioDualSolution <- function(model,
                                       jScenario)
{
    ans <- .Call("rcLSgetScenarioDualSolution", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetScenarioSlacks <- function(model,
                                 jScenario)
{
    ans <- .Call("rcLSgetScenarioSlacks", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetNodeListByScenario <- function(model,
                                     jScenario)
{
    ans <- .Call("rcLSgetNodeListByScenario", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetProbabilityByScenario <- function(model,
                                        jScenario)
{
    ans <- .Call("rcLSgetProbabilityByScenario", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetProbabilityByNode <- function(model,
                                    iNode)
{
    ans <- .Call("rcLSgetProbabilityByNode", PACKAGE = "rLindo", 
                 model,
                 as.integer(iNode))
    return(ans)
}

rLSgetStocParData <- function(model)
{
    ans <- .Call("rcLSgetStocParData", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSaddDiscreteBlocks <- function(model,
                                 iStage,
                                 nRealzBlock,
                                 padProb,
                                 pakStart,
                                 paiRows,
                                 paiCols,
                                 paiStvs,
                                 padVals,
                                 nModifyRule)
{
    ans <- .Call("rcLSaddDiscreteBlocks", PACKAGE = "rLindo", 
                 model,
                 as.integer(iStage),
                 as.integer(nRealzBlock),
                 as.numeric(padProb),
                 as.integer(pakStart),
                 as.integer(paiRows),
                 as.integer(paiCols),
                 as.integer(paiStvs),
                 as.numeric(padVals),
                 as.integer(nModifyRule))
    return(ans)
}

rLSaddScenario <- function(model,
                           jScenario,
                           iParentScen,
                           iStage,
                           dProb,
                           nElems,
                           paiRows,
                           paiCols,
                           paiStvs,
                           padVals,
                           nModifyRule)
{
    ans <- .Call("rcLSaddScenario", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario),
                 as.integer(iParentScen),
                 as.integer(iStage),
                 as.numeric(dProb),
                 as.integer(nElems),
                 as.integer(paiRows),
                 as.integer(paiCols),
                 as.integer(paiStvs),
                 as.numeric(padVals),
                 as.integer(nModifyRule))
    return(ans)
}

rLSaddDiscreteIndep <- function(model,
                                iRow,
                                jCol,
                                iStv,
                                nRealizations,
                                padProbs,
                                padVals,
                                nModifyRule)
{
    ans <- .Call("rcLSaddDiscreteIndep", PACKAGE = "rLindo", 
                 model,
                 as.integer(iRow),
                 as.integer(jCol),
                 as.integer(iStv),
                 as.integer(nRealizations),
                 as.numeric(padProbs),
                 as.numeric(padVals),
                 as.integer(nModifyRule))
    return(ans)
}

rLSaddParamDistIndep <- function(model,
                                 iRow,
                                 jCol,
                                 iStv,
                                 nDistType,
                                 nParams,
                                 padParams,
                                 iModifyRule)
{
    ans <- .Call("rcLSaddParamDistIndep", PACKAGE = "rLindo", 
                 model,
                 as.integer(iRow),
                 as.integer(jCol),
                 as.integer(iStv),
                 as.integer(nDistType),
                 as.integer(nParams),
                 as.numeric(padParams),
                 as.integer(iModifyRule))
    return(ans)
}

rLSaddChanceConstraint <- function(model,
                                   iSense,
                                   nCons,
                                   paiCons,
                                   dPrLevel,
                                   dObjWeight)
{
    ans <- .Call("rcLSaddChanceConstraint", PACKAGE = "rLindo", 
                 model,
                 as.integer(iSense),
                 as.integer(nCons),
                 as.integer(paiCons),
                 as.numeric(dPrLevel),
                 as.integer(dObjWeight))
    return(ans)
}

rLSsetNumStages <- function(model,
                            numStages)
{
    ans <- .Call("rcLSsetNumStages", PACKAGE = "rLindo", 
                 model,
                 as.integer(numStages))
    return(ans)
}

rLSgetStocParOutcomes <- function(model,
                                  jScenario)
{
    ans <- .Call("rcLSgetStocParOutcomes", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSloadCorrelationMatrix <- function(model,
                                     nDim,
                                     nCorrType,
                                     nQCnnz,
                                     paiQCcols1,
                                     paiQCcols2,
                                     padQCcoef)
{
    ans <- .Call("rcLSloadCorrelationMatrix", PACKAGE = "rLindo", 
                 model,
                 as.integer(nDim),
                 as.integer(nCorrType),
                 as.integer(nQCnnz),
                 as.integer(paiQCcols1),
                 as.integer(paiQCcols2),
                 as.numeric(padQCcoef))
    return(ans)
}

rLSgetCorrelationMatrix <- function(model,
                                    iFlag,
                                    nCorrType)
{
    ans <- .Call("rcLSgetCorrelationMatrix", PACKAGE = "rLindo", 
                 model,
                 as.integer(iFlag),
                 as.integer(nCorrType))
    return(ans)
}

rLSgetStocParSample <- function(model,
                                iStv,
                                iRow,
                                jCol)
{
    ans <- .Call("rcLSgetStocParSample", PACKAGE = "rLindo", 
                 model,
                 as.integer(iStv),
                 as.integer(iRow),
                 as.integer(jCol))
    return(ans)
}

rLSgetDiscreteBlocks <- function(model,
                                 iEvent)
{
    ans <- .Call("rcLSgetDiscreteBlocks", PACKAGE = "rLindo", 
                 model,
                 as.integer(iEvent))
    return(ans)
}

rLSgetDiscreteBlockOutcomes <- function(model,
                                        iEvent,
                                        iRealz)
{
    ans <- .Call("rcLSgetDiscreteBlockOutcomes", PACKAGE = "rLindo", 
                 model,
                 as.integer(iEvent),
                 as.integer(iRealz))
    return(ans)
}

rLSgetDiscreteIndep <- function(model,
                                iEvent)
{
    ans <- .Call("rcLSgetDiscreteIndep", PACKAGE = "rLindo", 
                 model,
                 as.integer(iEvent))
    return(ans)
}

rLSgetParamDistIndep <- function(model,
                                 iEvent)
{
    ans <- .Call("rcLSgetParamDistIndep", PACKAGE = "rLindo", 
                 model,
                 as.integer(iEvent))
    return(ans)
}

rLSgetScenario <- function(model,
                           jScenario)
{
    ans <- .Call("rcLSgetScenario", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSgetChanceConstraint <- function(model,
                                   iChance)
{
    ans <- .Call("rcLSgetChanceConstraint", PACKAGE = "rLindo", 
                 model,
                 as.integer(iChance))
    return(ans)
}

rLSgetSampleSizes <- function(model)
{
    ans <- .Call("rcLSgetSampleSizes", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetConstraintStages <- function(model)
{
    ans <- .Call("rcLSgetConstraintStages", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetVariableStages <- function(model)
{
    ans <- .Call("rcLSgetVariableStages", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetStocRowIndices <- function(model)
{
    ans <- .Call("rcLSgetStocRowIndices", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSsetStocParRG <- function(model,
                            iStv,
                            iRow,
                            jCol,
                            pRG)
{
    ans <- .Call("rcLSsetStocParRG", PACKAGE = "rLindo", 
                 model,
                 as.integer(iStv),
                 as.integer(iRow),
                 as.integer(jCol),
                 pRG)
    return(ans)
}

rLSgetScenarioModel <- function(model,
                                jScenario)
{
    ans <- .Call("rcLSgetScenarioModel", PACKAGE = "rLindo", 
                 model,
                 as.integer(jScenario))
    return(ans)
}

rLSfreeStocMemory <- function(model)
{
    ans <- .Call("rcLSfreeStocMemory", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSfreeStocHashMemory <- function(model)
{
    ans <- .Call("rcLSfreeStocHashMemory", PACKAGE = "rLindo", 
                 model)
    return(ans)
}

rLSgetModelStocParameterInt <- function(model,
                                        nQuery)
{
    ans <- .Call("rcLSgetModelStocParameterInt", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery))
    return(ans)
}

rLSgetModelStocParameterDou <- function(model,
                                        nQuery)
{
    ans <- .Call("rcLSgetModelStocParameterDou", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery))
    return(ans)
}

rLSgetModelStocParameterChar <- function(model,
                                         nQuery)
{
    ans <- .Call("rcLSgetModelStocParameterChar", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery))
    return(ans)
}

rLSsetModelStocParameterInt <- function(model,
                                        nQuery,
                                        pnResult)
{
    ans <- .Call("rcLSsetModelStocParameterInt", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.integer(pnResult))
    return(ans)
}

rLSsetModelStocParameterDou <- function(model,
                                        nQuery,
                                        pdResult)
{
    ans <- .Call("rcLSsetModelStocParameterInt", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.numeric(pdResult))
    return(ans)
}

rLSsetModelStocParameterChar <- function(model,
                                         nQuery,
                                         pacResult)
{
    ans <- .Call("rcLSsetModelStocParameterChar", PACKAGE = "rLindo", 
                 model,
                 as.integer(nQuery),
                 as.character(pacResult))
    return(ans)
}

rLSgetEnvStocParameterInt <- function(env,
                                      nQuery)
{
    ans <- .Call("rcLSgetEnvStocParameterInt", PACKAGE = "rLindo", 
                 env,
                 as.integer(nQuery))
    return(ans)
}

rLSgetEnvStocParameterDou <- function(env,
                                      nQuery)
{
    ans <- .Call("rcLSgetEnvStocParameterDou", PACKAGE = "rLindo", 
                 env,
                 as.integer(nQuery))
    return(ans)
}

rLSgetEnvStocParameterChar <- function(env,
                                       nQuery)
{
    ans <- .Call("rcLSgetEnvStocParameterChar", PACKAGE = "rLindo", 
                 env,
                 as.integer(nQuery))
    return(ans)
}

rLSsetEnvStocParameterInt <- function(env,
                                      nQuery,
                                      pnResult)
{
    ans <- .Call("rcLSsetEnvStocParameterInt", PACKAGE = "rLindo", 
                 env,
                 as.integer(nQuery),
                 as.integer(pnResult))
    return(ans)
}

rLSsetEnvStocParameterDou <- function(env,
                                      nQuery,
                                      pdResult)
{
    ans <- .Call("rcLSsetEnvStocParameterInt", PACKAGE = "rLindo", 
                 env,
                 as.integer(nQuery),
                 as.numeric(pdResult))
    return(ans)
}

rLSsetEnvStocParameterChar <- function(env,
                                       nQuery,
                                       pacResult)
{
    ans <- .Call("rcLSsetEnvStocParameterChar", PACKAGE = "rLindo", 
                 env,
                 as.integer(nQuery),
                 as.character(pacResult))
    return(ans)
}

#**************************************************************#
# Statistical Calculations Interface (15)                      #
#**************************************************************#
rLSsampCreate <- function(env,
                          nDistType)
{
    ans <- .Call("rcLSsampCreate", PACKAGE = "rLindo", 
                 env,
                 as.integer(nDistType))
    return(ans)
}

rLSsampDelete <- function(sample)
{
    ans <- .Call("rcLSsampDelete", PACKAGE = "rLindo", 
                 sample)
    return(ans)
}

rLSsampSetDistrParam <- function(sample,
                                 nIndex,
                                 dValue)
{
    ans <- .Call("rcLSsampSetDistrParam", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nIndex),
                 as.numeric(dValue))
    return(ans)
}

rLSsampGetDistrParam <- function(sample,
                                 nIndex)
{
    ans <- .Call("rcLSsampGetDistrParam", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nIndex))
    return(ans)
}

rLSsampEvalDistr <- function(sample,
                             nFuncType,
                             dXval)
{
    ans <- .Call("rcLSsampEvalDistr", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nFuncType),
                 as.numeric(dXval))
    return(ans)
}

rLSsampEvalUserDistr <- function(sample,
                                 nFuncType,
                                 padXval,
                                 nDim)
{
    ans <- .Call("rcLSsampEvalUserDistr", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nFuncType),
                 as.numeric(padXval),
                 as.integer(nDim))
    return(ans)
}

rLSsampSetRG <- function(sample,
                         RG)
{
    ans <- .Call("rcLSsampSetRG", PACKAGE = "rLindo", 
                 sample,
                 RG)
    return(ans)
}

rLSsampGenerate <- function(sample,
                            nMethod,
                            nSize)
{
    ans <- .Call("rcLSsampGenerate", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nMethod),
                 as.integer(nSize))
    return(ans)
}

rLSsampGetPoints <- function(sample)
{
    ans <- .Call("rcLSsampGetPoints", PACKAGE = "rLindo", 
                 sample)
    return(ans)
}

rLSsampLoadPoints <- function(sample,
                              nSampSize,
                              padXval)
{
    ans <- .Call("rcLSsampLoadPoints", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nSampSize),
                 as.numeric(padXval))
    return(ans)
}

rLSsampGetCIPoints <- function(sample)
{
    ans <- .Call("rcLSsampGetCIPoints", PACKAGE = "rLindo", 
                 sample)
    return(ans)
}

rLSsampLoadDiscretePdfTable <- function(sample,
                                        nLen,
                                        padProb,
                                        padVals)
{
    ans <- .Call("rcLSsampLoadDiscretePdfTable", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nLen),
                 as.numeric(padProb),
                 as.numeric(padVals))
    return(ans)
}

rLSsampGetDiscretePdfTable <- function(sample)
{
    ans <- .Call("rcLSsampGetDiscretePdfTable", PACKAGE = "rLindo", 
                 sample)
    return(ans)
}

rLSsampGetIInfo <- function(sample,
                            nQuery)
{
    ans <- .Call("rcLSsampGetIInfo", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nQuery))
    return(ans)
}

rLSsampGetDInfo <- function(sample,
                            nQuery)
{
    ans <- .Call("rcLSsampGetDInfo", PACKAGE = "rLindo", 
                 sample,
                 as.integer(nQuery))
    return(ans)
}

#**************************************************************#
# Random Number Generation Interface (12)                      #
#**************************************************************#
rLScreateRG <- function(env,
                        nMethod)
{
    ans <- .Call("rcLScreateRG", PACKAGE = "rLindo", 
                 env,
                 as.integer(nMethod))
    return(ans)
}

rLScreateRGMT <- function(env,
                          nMethod)
{
    ans <- .Call("rcLScreateRGMT", PACKAGE = "rLindo", 
                 env,
                 as.integer(nMethod))
    return(ans)
}

rLSgetDoubleRV <- function(rg)
{
    ans <- .Call("rcLSgetDoubleRV", PACKAGE = "rLindo", 
                 rg)
    return(ans)
}

rLSgetInt32RV <- function(rg,
                          iLow,
                          iHigh)
{
    ans <- .Call("rcLSgetInt32RV", PACKAGE = "rLindo", 
                 rg,
                 as.integer(iLow),
                 as.integer(iHigh))
    return(ans)
}

rLSsetRGSeed <- function(rg,
                         nSeed)
{
    ans <- .Call("rcLSsetRGSeed", PACKAGE = "rLindo", 
                 rg,
                 as.integer(nSeed))
    return(ans)
}

rLSdisposeRG <- function(rg)
{
    ans <- .Call("rcLSdisposeRG", PACKAGE = "rLindo", 
                 rg)
    return(ans)
}

rLSsetDistrParamRG <- function(rg,
                               iParam,
                               dParam)
{
    ans <- .Call("rcLSsetDistrParamRG", PACKAGE = "rLindo", 
                 rg,
                 as.integer(iParam),
                 as.numeric(dParam))
    return(ans)
}

rLSsetDistrRG <- function(rg,
                          nDistType)
{
    ans <- .Call("rcLSsetDistrRG", PACKAGE = "rLindo", 
                 rg,
                 as.integer(nDistType))
    return(ans)
}

rLSgetDistrRV <- function(rg)
{
    ans <- .Call("rcLSgetDistrRV", PACKAGE = "rLindo", 
                 rg)
    return(ans)
}

rLSgetInitSeed <- function(rg)
{
    ans <- .Call("rcLSgetInitSeed", PACKAGE = "rLindo", 
                 rg)
    return(ans)
}

rLSgetRGNumThreads <- function(rg)
{
    ans <- .Call("rcLSgetRGNumThreads", PACKAGE = "rLindo", 
                 rg)
    return(ans)
}

rLSfillRGBuffer <- function(rg)
{
    ans <- .Call("rcLSfillRGBuffer", PACKAGE = "rLindo", 
                 rg)
    return(ans)
}

#**************************************************************#
# Sprint Interface (1)                                         #
#**************************************************************#
rLSsolveFileLP <- function(model,
                           szFileNameMPS,
                           szFileNameSol,
                           nNoOfColsEvaluatedPerSet,
                           nNoOfColsSelectedPerSet,
                           nTimeLimitSec)
{
    ans <- .Call("rcLSsolveFileLP", PACKAGE = "rLindo", 
                 model,
                 as.character(szFileNameMPS),
                 as.character(szFileNameSol),
                 as.integer(nNoOfColsEvaluatedPerSet),
                 as.integer(nNoOfColsSelectedPerSet),
                 as.integer(nTimeLimitSec))
    return(ans)
}

#**************************************************************#
# Branch and price (1)                                         #
#**************************************************************#
rLSsolveMipBnp <- function(model,
                           nBlock,
                           pszFname)
{
    ans <- .Call("rcLSsolveMipBnp", PACKAGE = "rLindo", 
                 model,
                 as.integer(nBlock),
                 as.character(pszFname))
    return(ans)
}

Try the rLindo package in your browser

Any scripts or data that you put into this service are public.

rLindo documentation built on May 1, 2019, 10:11 p.m.

R Package Documentation

rdrr.io home R language documentation Run R code online

Browse R Packages

CRAN packages Bioconductor packages R-Forge packages GitHub packages

We want your feedback!

Note that we can't provide technical support on individual packages. You should contact the package authors for that.
GitHub issue tracker
ian@mutexlabs.com
Personal blog

 
Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.

Close