rneos/ 0000755 0001762 0000144 00000000000 13032675323 011404 5 ustar ligges users rneos/inst/ 0000755 0001762 0000144 00000000000 13031773676 012372 5 ustar ligges users rneos/inst/ExAMPL/ 0000755 0001762 0000144 00000000000 13031773676 013420 5 ustar ligges users rneos/inst/ExAMPL/diet.mod 0000644 0001762 0000144 00000000612 11435716663 015044 0 ustar ligges users set NUTR;
set FOOD;
param cost {FOOD} > 0;
param f_min {FOOD} >= 0;
param f_max {j in FOOD} >= f_min[j];
param n_min {NUTR} >= 0;
param n_max {i in NUTR} >= n_min[i];
param amt {NUTR,FOOD} >= 0;
var Buy {j in FOOD} >= f_min[j], <= f_max[j];
minimize Total_Cost: sum {j in FOOD} cost[j] * Buy[j];
subject to Diet {i in NUTR}:
n_min[i] <= sum {j in FOOD} amt[i,j] * Buy[j] <= n_max[i];
rneos/inst/ExAMPL/diet.dat 0000644 0001762 0000144 00000001317 11435716652 015036 0 ustar ligges users data;
set NUTR := A B1 B2 C ;
set FOOD := BEEF CHK FISH HAM MCH MTL SPG TUR ;
param: cost f_min f_max :=
BEEF 3.19 0 100
CHK 2.59 0 100
FISH 2.29 0 100
HAM 2.89 0 100
MCH 1.89 0 100
MTL 1.99 0 100
SPG 1.99 0 100
TUR 2.49 0 100 ;
param: n_min n_max :=
A 700 10000
C 700 10000
B1 700 10000
B2 700 10000 ;
param amt (tr):
A C B1 B2 :=
BEEF 60 20 10 15
CHK 8 0 20 20
FISH 8 10 15 10
HAM 40 40 35 10
MCH 15 35 15 15
MTL 70 30 15 15
SPG 25 50 25 15
TUR 60 20 15 10 ;
rneos/inst/ExGAMS/ 0000755 0001762 0000144 00000000000 13031773676 013416 5 ustar ligges users rneos/inst/ExGAMS/TwoStageStochastic.gms 0000644 0001762 0000144 00000004057 11547576307 017720 0 ustar ligges users $TITLE Stochastic Two-stage program
* TwoStageStochastic.gms: Stochastic Two-stage program.
* Consiglio, Nielsen and Zenios.
* PRACTICAL FINANCIAL OPTIMIZATION: A Library of GAMS Models, Section 6.3.1
* Last modified: Apr 2008.
SET Assets Available assets
/Stock, Put_1, Call_1, Put_2, Call_2/;
SET Assets_1(Assets) Assets available up to the end of the first stage
/Stock, Put_1, Call_1/;
SET Assets_2(Assets) Assets available up to the end of the second stage
/Stock, Put_2, Call_2/;
SET Scenarios Set of scenarios
/SS_1 * SS_3/;
ALIAS (Assets, i );
ALIAS (Assets_1, j);
ALIAS (Assets_2, k);
ALIAS (Scenarios, l);
PARAMETER pr(l) Scenario probability
/SS_1 = 0.25,
SS_2 = 0.50,
SS_3 = 0.25/;
PARAMETER P_1(j) Asset prices at the beginning of the first stage
/Stock = 43,
Put_1 = 0.81,
Call_1 = 4.76/;
TABLE P_2(l,i) Asset prices (values) at the beginning of the second stage
Stock Put_1 Call_1 Put_2 Call_2
SS_1 44 1 0 0.92 4.43
SS_2 36 0 4 1.40 0.85
SS_3 47 2 0 3.02 6.82;
TABLE V(l,k) Asset prices (values) at the end of the second stage
Stock Put_2 Call_2
SS_1 48 1 0
SS_2 32 0 3
SS_3 55 4 0;
POSITIVE VARIABLES
x(j) First-stage holdings
y(l,k) Second-stage holdings;
VARIABLE
z Objective function value;
EQUATIONS
BudgetCon Equation defining the budget contraint
ObjDef Objective function definition
MinReturnCon(l) Equation defining the minimum return contraint
RebalanceCon(l) Equation defining the rebalance contraint;
ObjDef .. z =E= SUM((k,l), pr(l) * V(l,k) * y(l,k));
BudgetCon .. SUM(j, P_1(j) * x(j)) =L= 10000;
MinReturnCon(l) .. SUM(k, V(l,k) * y(l,k)) =G= 11500;
RebalanceCon(l) .. SUM(j, P_2(l,j) * x(j)) =G= SUM(k, P_2(l,k) * y(l,k));
MODEL StochasticTwoStage /ALL/;
SOLVE StochasticTwoStage MAXIMIZING z USING LP;
DISPLAY x.l,z.l;
rneos/NAMESPACE 0000644 0001762 0000144 00000001441 12447005345 012623 0 ustar ligges users ##
## Import directives
##
import(XML)
import(RCurl)
import(methods)
## Import functions
importFrom(stats, update)
##
## Export of functions
##
export(CreateNeosComm,
CreateXmlString,
NemailHelp,
NgetFinalResults,
NgetFinalResultsNonBlocking,
NgetIntermediateResults,
NgetIntermediateResultsNonBlocking,
NgetJobInfo,
NgetJobStatus,
NgetSolverTemplate,
Nhelp,
NkillJob,
NlistAllSolvers,
NlistCategories,
NlistSolversInCategory,
Nping,
NprintQueue,
NsubmitJob,
Nversion,
Nwelcome)
##
## Export of S4-classes
##
exportClasses(NeosComm, NeosAns, NeosXml, NeosJob, NeosOff)
##
## Export of S4-methods
##
exportMethods(show, update)
rneos/R/ 0000755 0001762 0000144 00000000000 13031773676 011616 5 ustar ligges users rneos/R/AllClasses.R 0000644 0001762 0000144 00000001607 11546574157 013775 0 ustar ligges users ##
## Class for NEOS communication objects
##
setClass("NeosComm", representation(url = "character", curlopts = "list", curlhandle = "CURLHandle"))
##
## Class for returned Values from requests to NEOS
##
setClass("NeosAns", representation(ans = "character", method = "character", call = "call", nc = "NeosComm"))
##
## Class for returned XML template from NEOS
##
setClass("NeosXml", representation(xml = "XMLNode", method = "character", call = "call", nc = "NeosComm"))
##
## Class for assigned jobnumber and password from NEOS
##
setClass("NeosJob", representation(jobnumber = "numeric", password = "character", method = "character", call = "call", nc = "NeosComm"))
##
## Class for NEOS offset
##
setClass("NeosOff", representation(ans = "character", offset = "integer", jobnumber = "numeric", password = "character", method = "character", call = "call", nc = "NeosComm"))
rneos/R/Nping.R 0000644 0001762 0000144 00000001226 12447262077 013013 0 ustar ligges users ##
## XML-RPC method: ping()
##
Nping <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "ping", .convert = convert,
.opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "ping", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/show-methods.R 0000644 0001762 0000144 00000001723 11546600274 014355 0 ustar ligges users ##
## show-method for objects of class NeosAns
##
setMethod("show", "NeosAns", function(object){
if(is.character(object@ans) && length(object@ans) == 1){
cat("\n")
cat(object@ans)
cat("\n")
} else {
print(object@ans)
}
})
##
## show-method for objects of class NeosXml
##
setMethod("show", "NeosXml", function(object){
print(object@xml)
})
##
## show-method for objects of class NeosJob
##
setMethod("show", "NeosJob", function(object){
cat("\n")
cat(paste("The job number is:", object@jobnumber, "\n"))
cat(paste("The pass word is :", object@password, "\n"))
cat("\n")
})
##
## show-method for objects of class NeosOff
##
setMethod("show", "NeosOff", function(object){
title <- paste("# The new offset is:", object@offset, "#", sep=" ")
row <- paste(rep("#", nchar(title)), collapse="")
cat("\n")
cat(object@ans)
cat("\n")
cat(row, "\n")
cat(title, "\n")
cat(row, "\n")
cat("\n")
})
rneos/R/update-methods.R 0000644 0001762 0000144 00000001203 11550567145 014654 0 ustar ligges users ##
## Methods for updating an existing object
## =======================================
##
## Method definition for objects of class "NeosOff"
##
setMethod("update", signature(object = "NeosOff"), function(object, formula.,..., evaluate = TRUE){
call <- object@CALL
extras <- match.call(expand.dots = FALSE)$...
if (length(extras) > 0) {
existing <- !is.na(match(names(extras), names(call)))
for (a in names(extras)[existing]) call[[a]] <- extras[[a]]
if (any(!existing)) {
call <- c(as.list(call), extras[!existing])
call <- as.call(call)
}
}
if (evaluate)
eval(call, parent.frame())
else call
})
rneos/R/NgetFinalResults.R 0000644 0001762 0000144 00000002021 12447261752 015162 0 ustar ligges users ##
## XML-RPC method: getFinalResults()
##
NgetFinalResults <- function(obj, convert = TRUE){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if (!(class(obj) == "NeosJob")) {
stop("\nObject 'obj' is not of class 'NeosJob'.\n")
}
call <- match.call()
jobnumber <- obj@jobnumber
password <- obj@password
nc <- obj@nc
ans <- XMLRPC::xml.rpc(url = nc@url, method = "getFinalResults",
.args = list(jobnumber = jobnumber, password = password),
.convert = FALSE, .opts = nc@curlopts, .curl = nc@curlhandle)
if(convert){
tmp <- xmlValue(xmlRoot(xmlParse(ans)))
tmp <- gsub("\\n", "", tmp)
class(tmp) <- "base64"
ans <- base64(tmp)
}
res <- new("NeosAns", ans = ans, method = "getFinalResults", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NlistCategories.R 0000644 0001762 0000144 00000001441 12447262055 015032 0 ustar ligges users ##
## XML-RPC method: listCategories()
##
NlistCategories <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "listCategories",
.convert = convert, .opts = nc@curlopts, .curl = nc@curlhandle)
if(convert){
ans <- paste(names(ans), as.character(ans), sep = ": ")
}
res <- new("NeosAns", ans = ans, method = "listCategories", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NgetJobStatus.R 0000644 0001762 0000144 00000001510 12447262010 014453 0 ustar ligges users ##
## XML-RPC method: getJobStatus()
##
NgetJobStatus <- function(obj, convert = TRUE){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(obj) == "NeosJob")){
stop("\nObject 'obj' is not of class 'NeosJob'.\n")
}
call <- match.call()
jobnumber <- obj@jobnumber
password <- obj@password
nc <- obj@nc
ans <- XMLRPC::xml.rpc(url = nc@url, method = "getJobStatus",
.args = list(jobnumber = jobnumber, password = password),
.convert = convert, .opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "getJobStatus", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NsubmitJob.R 0000644 0001762 0000144 00000001534 12447262113 014005 0 ustar ligges users ##
## XML-RPC method: submitJob()
##
NsubmitJob <- function(xmlstring, user = "rneos", interface = "", id = 0, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")) {
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "submitJob",
.args = list(xmlstring = xmlstring, user = user, interface = interface, id = id),
.convert = TRUE, .opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosJob", jobnumber = ans[[1]], password = ans[[2]], method = "submitJob", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NemailHelp.R 0000644 0001762 0000144 00000001252 12447261735 013755 0 ustar ligges users ##
## XML-RPC method: emailHelp()
##
NemailHelp <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "emailHelp", .convert = convert,
.opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "emailHelp", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NgetJobInfo.R 0000644 0001762 0000144 00000001503 12447261777 014110 0 ustar ligges users ##
## XML-RPC method: getJobInfo()
##
NgetJobInfo <- function (obj, convert = TRUE){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if (!(class(obj) == "NeosJob")) {
stop("\nObject 'obj' is not of class 'NeosJob'.\n")
}
call <- match.call()
jobnumber <- obj@jobnumber
password <- obj@password
nc <- obj@nc
ans <- XMLRPC::xml.rpc(url = nc@url, method = "getJobInfo",
.args = list(jobnumber = jobnumber, password = password),
.convert = convert, .opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "getJobInfo", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NgetFinalResultsNonBlocking.R 0000644 0001762 0000144 00000002075 12447335412 017312 0 ustar ligges users ##
## XML-RPC method: getFinalResultsNonBlocking()
##
NgetFinalResultsNonBlocking <- function(obj, convert = TRUE){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if (!(class(obj) == "NeosJob")) {
stop("\nObject 'obj' is not of class 'NeosJob'.\n")
}
call <- match.call()
jobnumber <- obj@jobnumber
password <- obj@password
nc <- obj@nc
ans <- XMLRPC::xml.rpc(url = nc@url, method = "getFinalResultsNonBlocking",
.args = list(jobnumber = jobnumber, password = password),
.convert = FALSE, .opts = nc@curlopts, .curl = nc@curlhandle)
if(convert){
tmp <- xmlValue(xmlRoot(xmlParse(ans)))
tmp <- gsub("\\n", "", tmp)
class(tmp) <- "base64"
ans <- base64(tmp)
}
res <- new("NeosAns", ans = ans, method = "getFinalResultsNonBlocking", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NlistAllSolvers.R 0000644 0001762 0000144 00000001276 12447262046 015041 0 ustar ligges users ##
## XML-RPC method: listAllSolvers()
##
NlistAllSolvers <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "listAllSolvers", .convert = convert,
.opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "listAllSolvers", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NkillJob.R 0000644 0001762 0000144 00000001727 12447262040 013440 0 ustar ligges users ##
## XML-RPC method: killJob()
##
NkillJob <- function(obj, killmsg = NULL, convert = TRUE){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(obj) == "NeosJob")){
stop("\nObject 'obj' is not of class 'NeosJob'.\n")
}
call <- match.call()
jobnumber <- obj@jobnumber
password <- obj@password
nc <- obj@nc
if(is.null(killmsg)){
killmsg <- ""
} else {
killmsg <- as.character(killmsg)
}
ans <- XMLRPC::xml.rpc(url = nc@url, method = "killJob",
.args = list(jobnumber = jobnumber, password = password, killmsg = killmsg),
.convert = convert, .opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "killJob", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/Nwelcome.R 0000644 0001762 0000144 00000001242 12447262130 013475 0 ustar ligges users ##
## XML-RPC method: welcome()
##
Nwelcome <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "welcome", .convert = convert,
.opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "welcome", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/Nversion.R 0000644 0001762 0000144 00000001252 12447262122 013531 0 ustar ligges users ##
## XML-RPC method: version()
##
Nversion <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "version", .convert = convert,
.opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "version", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/CreateNeosComm.R 0000644 0001762 0000144 00000001237 13030206534 014567 0 ustar ligges users CreateNeosComm <- function(curlopts = list(httpheader = c(`Content-Type` = "text/xml", 'User-Agent' = "R"), port = 3333), curlhandle = getCurlHandle()){
url <- "https://www.neos-server.org"
if(!("httpheader" %in% names(curlopts))){
stop("\nNo 'httpheader' list element has been specified in 'curlopts'.\n")
}
if(!("port" %in% names(curlopts))){
stop("\nNo 'port' list element has been specified in 'curlopts'.\n")
}
if(!(class(curlhandle) == "CURLHandle")){
stop("\nObject for 'curlhandle' must be of class 'CURLHandle'.\n")
}
result <- new("NeosComm", url = url, curlopts = curlopts, curlhandle = curlhandle)
return(result)
}
rneos/R/NgetIntermediateResults.R 0000644 0001762 0000144 00000002757 12447335422 016557 0 ustar ligges users ##
## XML-RPC method: getIntermediateResults
##
NgetIntermediateResults <- function (obj, offset = NULL, convert = TRUE){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if (!(class(obj) == "NeosJob")) {
stop("\nObject 'obj' is not of class 'NeosJob'.\n")
}
call <- match.call()
jobnumber <- obj@jobnumber
password <- obj@password
nc <- obj@nc
if(is.null(offset)){
offset <- as.integer(0)
} else {
offset <- as.integer(offset)
}
ans <- XMLRPC::xml.rpc(url = nc@url, method = "getIntermediateResults",
.args = list(jobnumber = jobnumber, password = password, offset = offset),
.convert = FALSE, .opts = nc@curlopts, .curl = nc@curlhandle)
tmp <- xmlToList(xmlRoot(xmlTreeParse(ans)))
offset <- as.integer(tmp[2, ])
if (convert) {
tmp1 <- tmp[1, ]
if(!is.null(tmp1$params)){
tmp1 <- gsub("\\n", "", tmp1)
class(tmp1) <- "base64"
ans <- base64(tmp1)
} else {
ans <- "\nNothing left to return from NEOS.\n"
}
}
res <- new("NeosOff", ans = ans, offset = offset, jobnumber = jobnumber, password = password, method = "getIntermediateResults", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/Nhelp.R 0000644 0001762 0000144 00000001226 12447262030 012773 0 ustar ligges users ##
## XML-RPC method: help()
##
Nhelp <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "help", .convert = convert,
.opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "help", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/CreateXmlString.R 0000644 0001762 0000144 00000001212 11434522117 014773 0 ustar ligges users ##
## Function: CreateXmlString
##
CreateXmlString <- function(neosxml, cdatalist){
if(!(class(neosxml) == "NeosXml")){
stop("\nPlease provide an object of class 'NeosXml' for argument neosxml.\n")
}
xmlstr <- neosxml@xml
lnames <- names(cdatalist)
if(!(all(lnames %in% names(xmlstr)))){
stop("\nNamed list object 'cdatalist' does contain entries that are not node names of object 'xmlstr'.\n")
}
idx <- 1:length(cdatalist)
tmp <- removeChildren(xmlstr, kids = lnames)
for(i in idx){
tmp <- append.XMLNode(tmp, newXMLNode(lnames[i], cdatalist[[i]], cdata = TRUE))
}
ans <- toString(tmp)
return(ans)
}
rneos/R/NgetIntermediateResultsNonBlocking.R 0000644 0001762 0000144 00000003057 12447261770 020701 0 ustar ligges users ##
## XML-RPC method: getIntermediateResultsNonBlocking()
##
NgetIntermediateResultsNonBlocking <- function (obj, offset = NULL, convert = TRUE){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if (!(class(obj) == "NeosJob")) {
stop("\nObject 'obj' is not of class 'NeosJob'.\n")
}
call <- match.call()
jobnumber <- obj@jobnumber
password <- obj@password
nc <- obj@nc
if(is.null(offset)){
offset <- as.integer(0)
} else {
offset <- as.integer(offset)
}
ans <- XMLRPC::xml.rpc(url = nc@url, method = "getIntermediateResultsNonBlocking",
.args = list(jobnumber = jobnumber, password = password, offset = offset),
.convert = FALSE, .opts = nc@curlopts, .curl = nc@curlhandle)
tmp <- xmlToList(xmlRoot(xmlTreeParse(ans)))
offset <- as.integer(tmp[2, ])
if (convert) {
tmp1 <- tmp[1, ]
if(!is.null(tmp1$params)){
tmp1 <- gsub("\\n", "", tmp1)
class(tmp1) <- "base64"
ans <- base64(tmp1)
} else {
ans <- "\nNothing left to return from NEOS.\n"
}
}
res <- new("NeosOff", ans = ans, offset = offset, jobnumber = jobnumber, password = password,
method = "getIntermediateResultsNonBlocking", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NprintQueue.R 0000644 0001762 0000144 00000001256 12447262105 014212 0 ustar ligges users ##
## XML-RPC method: printQueue()
##
NprintQueue <- function(convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if(!(class(nc) == "NeosComm")){
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "printQueue", .convert = convert,
.opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "printQueue", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NgetSolverTemplate.R 0000644 0001762 0000144 00000001600 12447262021 015505 0 ustar ligges users ##
## NEOS: getSolverTemplate
##
NgetSolverTemplate <- function(category, solvername, inputMethod, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if (!(class(nc) == "NeosComm")) {
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "getSolverTemplate",
.args = list(category = category, solvername = solvername, inputMethod = inputMethod),
.convert = TRUE, .opts = nc@curlopts, .curl = nc@curlhandle)
xml <- xmlRoot(xmlTreeParse(ans, asText = TRUE))
res <- new("NeosXml", xml = xml, method = "getSolverTemplate", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/R/NlistSolversInCategory.R 0000644 0001762 0000144 00000002152 12447262064 016367 0 ustar ligges users ##
## XML-RPC method: listSolversInCategory()
##
NlistSolversInCategory <- function(category, convert = TRUE, nc = CreateNeosComm()){
if(requireNamespace("XMLRPC", quietly = TRUE)) {
if (!(class(nc) == "NeosComm")) {
stop("\nObject provided for 'nc' must be of class 'NeosComm'.\n")
}
category <- as.character(category)
cats <- NlistCategories(nc = nc)@ans
cats <- unlist(lapply(strsplit(cats, split = ":"), function(x) x[1]))
if(!category %in% cats){
stop(paste("\nSpecified category not available. Must be one of:\n", paste(cats, collapse = ", "), ".\n"))
}
call <- match.call()
ans <- XMLRPC::xml.rpc(url = nc@url, method = "listSolversInCategory",
.args = list(category = category),
.convert = convert, .opts = nc@curlopts, .curl = nc@curlhandle)
res <- new("NeosAns", ans = ans, method = "listCategories", call = call, nc = nc)
return(res)
} else {
stop("Package 'XMLRPC' not available, please install first from Omegahat.")
}
}
rneos/MD5 0000644 0001762 0000144 00000005516 13032675323 011723 0 ustar ligges users 2b96b440306076fcf06fa5aa9c403224 *DESCRIPTION
a9c43f8f6198594a7c59b2a7be57b4b8 *NAMESPACE
7b04273d5320ab6667ba429a6db272b5 *R/AllClasses.R
94c6055be97ed066b371257f4bf1572b *R/CreateNeosComm.R
76a2878b039efa5deee5e54ffcfb3862 *R/CreateXmlString.R
eaf3ee09bb8957ad9f513721be8748dc *R/NemailHelp.R
442d24f2d414b0f167c2cc552eff6ece *R/NgetFinalResults.R
08165309c0770e17b9a32f950a23e500 *R/NgetFinalResultsNonBlocking.R
ab50e446b063eb770511de34537bb9e5 *R/NgetIntermediateResults.R
fea36a08fe8bf5c09f5cc761493cab6d *R/NgetIntermediateResultsNonBlocking.R
b6aa1ab7bd66320e89bda23a9b5db733 *R/NgetJobInfo.R
11e67017629ac23c1ef3fbd302a8d4df *R/NgetJobStatus.R
dd05cd0186cc3daa4516faf533cef525 *R/NgetSolverTemplate.R
a28b81072ad9fe1d367940cf52fd75eb *R/Nhelp.R
1f9df21ab83af784a4a3f1588a6456b3 *R/NkillJob.R
d15b02a5ed6de0e0c842b1f9e12d190f *R/NlistAllSolvers.R
f4d4be44d4d571570bddd677064ee7d3 *R/NlistCategories.R
a1f77d87d50c14941ddac5e9f4aad49b *R/NlistSolversInCategory.R
063b7360fc79c8fb2b4e087bda3a9f47 *R/Nping.R
500127f271724fd79c897ab7c6f1b0fb *R/NprintQueue.R
9aa859a2666673649f6c52825c5b92ad *R/NsubmitJob.R
91c9513af2efd92829aa1ef6d17a4781 *R/Nversion.R
f350d5df61767058c391ab189154ce61 *R/Nwelcome.R
8012c64214ad7e6e948ef4bf0ed6ac20 *R/show-methods.R
84cd3dfac5ac1c5d9d24b917434ff3fd *R/update-methods.R
e92f448378d5d31319cd45a541b3920d *inst/ExAMPL/diet.dat
0c5c9af916ddbaa80447e644b907c4dc *inst/ExAMPL/diet.mod
2d5ed772d8f685ca9048147555c90a6c *inst/ExGAMS/TwoStageStochastic.gms
30128f5db3f260622c5dd5dbafd31f0e *man/CreateNeosComm.Rd
6730302da47dbb64147928b9607ebeef *man/CreateXmlString.Rd
0f5d43a712e68f45dd31cf16cc86a225 *man/NemailHelp.Rd
185bc7e0b71c950f182e27378492a124 *man/NeosAns-class.Rd
4ff277f19f456507902aadf869ddca68 *man/NeosComm-class.Rd
5b220b9667e95e24f1e7cf6244ebea8b *man/NeosJob-class.Rd
148b971fd9e524dcd7d3b7ee6ade7de7 *man/NeosOff-class.Rd
96e69b74d91d16db7f7a08c8f25be8d3 *man/NeosXml-class.Rd
dd971e7f14a28e89becb39fe4a010b9a *man/NgetFinalResults.Rd
3e5af925822d74cfca97f530978b6562 *man/NgetFinalResultsNonBlocking.Rd
2461449094490731f631f6b609b66fe4 *man/NgetIntermediateResults.Rd
8e59f7f293f5d34e8e02e32b1ad88d1b *man/NgetIntermediateResultsNonBlocking.Rd
a9f5085f915c935c0d21f707fb469c91 *man/NgetJobInfo.Rd
b1226aabc1bb6d1ee6c12229f7cd7e65 *man/NgetJobStatus.Rd
7fc82a2945120292fb24bd6925c01a86 *man/NgetSolverTemplate.Rd
918a48bee891529853b67419f437d706 *man/Nhelp.Rd
9c3fb033bd30bbf222868f93292c85f1 *man/NkillJob.Rd
c46b44c5d934c21cda8bb4a649030983 *man/NlistAllSolvers.Rd
c362754296ad16e87bb7d31f6a9cd3c0 *man/NlistCategories.Rd
5080ca1282d8ead877296ef868aa9073 *man/NlistServersInCategory.Rd
af743bd4030beeee2d74d434edfb227c *man/Nping.Rd
9b7b11017b77a3b616f46aed2d2dcc68 *man/NprintQueue.Rd
07a64a1e279a7c6d4609dc5fbdf56c96 *man/NsubmitJob.Rd
d6d19504f3b8b562419fc9777fbff701 *man/Nversion.Rd
6f95836d497f0163198d0bd93a8b5fa0 *man/Nwelcome.Rd
rneos/DESCRIPTION 0000644 0001762 0000144 00000001521 13032675323 013111 0 ustar ligges users Package: rneos
Version: 0.3-2
Date: 2016-12-31
Title: XML-RPC Interface to NEOS
Authors@R: person("Bernhard", "Pfaff", email = "bernhard@pfaffikus.de", role = c("aut", "cre"))
Depends: R (>= 2.10.0), methods, RCurl, XML, stats
Suggests: XMLRPC
Additional_repositories: http://www.omegahat.net/R
LazyLoad: yes
Description: Within this package the XML-RPC API to NEOS is implemented. This enables the user to pass optimization problems to NEOS and retrieve results within R.
License: GPL (>= 2)
Author: Bernhard Pfaff [aut, cre]
Maintainer: Bernhard Pfaff
Repository: CRAN
Repository/R-Forge/Project: rneos
Repository/R-Forge/Revision: 265
Repository/R-Forge/DateTimeStamp: 2016-12-31 18:19:43
Date/Publication: 2017-01-03 11:20:03
NeedsCompilation: no
Packaged: 2016-12-31 18:25:23 UTC; rforge
rneos/man/ 0000755 0001762 0000144 00000000000 13031773676 012170 5 ustar ligges users rneos/man/Nversion.Rd 0000644 0001762 0000144 00000002263 12666402323 014254 0 ustar ligges users \name{Nversion}
\alias{Nversion}
\title{
XML-RPC method version of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{version()} of NEOS and
returns an object of class \code{NeosAns}, which is a string
containing the version number of the NEOS server.
}
\usage{
Nversion(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
Nversion()
}
}
\keyword{IO}
rneos/man/NlistServersInCategory.Rd 0000644 0001762 0000144 00000002725 12666402323 017104 0 ustar ligges users \name{NlistSolversInCategory}
\alias{NlistSolversInCategory}
\title{
XML-RPC method listSolversInCategory of Neos
}
\description{
This functions calls the XML-RPC method
\dQuote{listSolversInCategory()} of NEOS and returns an object of
class \code{NeosAns}. The returned content is a list of solver:input
for every solver in the category (category can be abbreviation or
full\_name).
}
\usage{
NlistSolversInCategory(category, convert = TRUE,
nc = CreateNeosComm())
}
\arguments{
\item{category}{Character, the abbreviation of a category}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}}, \code{\link{NlistCategories}} and
\code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
NlistSolversInCategory(category = "go")
}
}
\keyword{IO}
rneos/man/Nping.Rd 0000644 0001762 0000144 00000002345 12666402323 013525 0 ustar ligges users \name{Nping}
\alias{Nping}
\title{
XML-RPC method ping of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{ping()} of NEOS and
returns an object of class \code{NeosAns}. It is verified that this
NeosServer is running and a message \sQuote{NeosServer is alive} is
returned.
}
\usage{
Nping(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}}, \code{\link{NlistCategories}} and
\code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
Nping()
}
}
\keyword{IO}
rneos/man/NeosJob-class.Rd 0000644 0001762 0000144 00000004453 13030210743 015103 0 ustar ligges users \name{NeosJob-class}
\Rdversion{1.1}
\docType{class}
\alias{NeosJob-class}
\alias{show,NeosJob-method}
\title{Class "NeosJob"}
\description{
Objects of this class contain among other slots the returned jobnumber
and password for jobs submitted to NEOS. Objects of this class can
then be used for retrieving the optimization results.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("NeosJob", ...)}
or more conveniently by calling the relevant R API function
\code{NsubmitJob}.
}
\section{Slots}{
\describe{
\item{\code{jobnumber}:}{Object of class \code{"numeric"}:
The returned job number.}
\item{\code{password}:}{Object of class \code{"character"}:
The returned pass word.}
\item{\code{method}:}{Object of class \code{"character"}:
The name of the called API function.}
\item{\code{call}:}{Object of class \code{"call"}:
The call to the generating function of the object.}
\item{\code{nc}:}{Object of class \code{"NeosComm"}:
The NeosComm object that has been used in the request to NEOS.}
}
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "NeosJob")}: Displays the slots
\code{jobnumber} and \code{password} from an object of class
\code{NeosJob}.}
}
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\examples{
showClass("NeosJob")
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
NsubmitJob(xmlstring = xmls, user = "rneos", interface = "", id = 0)
}
}
\keyword{classes}
\keyword{IO}
rneos/man/NeosOff-class.Rd 0000644 0001762 0000144 00000003154 12666402323 015113 0 ustar ligges users \name{NeosOff-class}
\Rdversion{1.1}
\docType{class}
\alias{NeosOff-class}
\alias{show,NeosOff-method}
\alias{update,NeosOff-method}
\title{Class "NeosOff"}
\description{
Objects of this class contain among other slots the partial result and
the offset.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("NeosOff", ...)}.
}
\section{Slots}{
\describe{
\item{\code{ans}:}{Object of class \code{"character"}: The partial
result returned from NEOS.}
\item{\code{offset}:}{Object of class \code{"integer"}: The integer
offset until the results have been returned.}
\item{\code{jobnumber}:}{Object of class \code{"numeric"}: The
returned job number.}
\item{\code{password}:}{Object of class \code{"character"}: The
returned pass word.}
\item{\code{method}:}{Object of class \code{"character"}: The name
of the called API function.}
\item{\code{call}:}{Object of class \code{"call"}: The call to the
generating function of the object.}
\item{\code{nc}:}{Object of class \code{"NeosComm"}: The NeosComm
object that has been used in the request to NEOS.}
}
}
\section{Methods}{
\describe{
\item{update}{Updates an object of class \code{NeosOff}.}
}
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\examples{
showClass("NeosOff")
}
\keyword{classes}
\keyword{IO}
rneos/man/NprintQueue.Rd 0000644 0001762 0000144 00000002265 12666402323 014732 0 ustar ligges users \name{NprintQueue}
\alias{NprintQueue}
\title{
XML-RPC method printQueue of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{printQueue()} of NEOS
and returns an object of class \code{NeosAns}, which is a string
containing the current NEOS jobs.
}
\usage{
NprintQueue(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
NprintQueue()
}
}
\keyword{IO}
rneos/man/NgetSolverTemplate.Rd 0000644 0001762 0000144 00000002646 12666402323 016242 0 ustar ligges users \name{NgetSolverTemplate}
\alias{NgetSolverTemplate}
\title{
XML-RPC method getSolverTemplate of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{getSolverTemplate()}
of NEOS. If the solver category:solvername:inputMethod exists on NEOS,
then an XML template is returned as an object of class \code{NeosXml}.
}
\usage{
NgetSolverTemplate(category, solvername, inputMethod,
nc = CreateNeosComm())
}
\arguments{
\item{category}{Character, the abbreviation of a category}
\item{solvername}{Character, the name of the solver to be used.}
\item{inputMethod}{Character, the name of the solver for which the
xml-template shall be returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosXml}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosXml}}, \code{\link{NlistAllSolvers}} and
\code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
NgetSolverTemplate(category = "go", solvername = "ASA", inputMethod = "AMPL")
}
}
\keyword{IO}
rneos/man/NeosAns-class.Rd 0000644 0001762 0000144 00000003014 12666402323 015115 0 ustar ligges users \name{NeosAns-class}
\Rdversion{1.1}
\docType{class}
\alias{NeosAns-class}
\alias{show,NeosAns-method}
\title{Class "NeosAns"}
\description{
Objects of this class contain the returned results from NEOS as well
as information on which kind of query has been sent and how it was sent.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("NeosAns", ...)}
or more conveniently by calling the relevant R API functions.
}
\section{Slots}{
\describe{
\item{\code{ans}:}{Object of class \code{"character"}: The returned
XML-RPC of NEOS as character string.}
\item{\code{method}:}{Object of class \code{"character"}: The name
of the called API function.}
\item{\code{call}:}{Object of class \code{"call"}: The call to the
generating function of the object.}
\item{\code{nc}:}{Object of class \code{"NeosComm"}: The NeosComm
object that has been used in the request to NEOS.}
}
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "NeosAns")}: Returns the
converted slot \code{ans} from an object of class \code{NeosAns}.}
}
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosComm}}
}
\examples{
showClass("NeosAns")
}
\keyword{classes}
\keyword{IO}
rneos/man/NgetIntermediateResultsNonBlocking.Rd 0000644 0001762 0000144 00000004753 13030210360 021375 0 ustar ligges users \name{NgetIntermediateResultsNonBlocking}
\alias{NgetIntermediateResultsNonBlocking}
\title{
XML-RPC method getIntermediateResultsNonBlocking of Neos
}
\description{
This functions calls the XML-RPC method
\dQuote{getIntermediateResultsNonBlocking()} of NEOS, which returns
intermediate results of a job submitted to NEOS, starting at the
character offset up to the last received data. Intermediate results
are usually the standard output of the solver daemon. If the job is
still running, then this function will hang until another packet of
output is sent to NEOS or the job is finished. This function will
return a tuple of thebase-64 encoded object and the new offset
(object, newoffset). The offset refers to uncoded characters.
}
\usage{
NgetIntermediateResultsNonBlocking(obj, offset = NULL,
convert = TRUE)
}
\arguments{
\item{obj}{NeosJob, an object of class \code{NeosJob} as returned by
the function \code{NsubmitJob}.}
\item{offset}{Integer, the offset from which on the results are
returned. In a first run this is set to \code{integer(0)}.}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned (base-64 encoded).}
}
\value{
An object of class \code{NeosOff}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosOff}} and \code{\link{NsubmitJob}}
}
\examples{
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
test <- NsubmitJob(xmlstring = xmls, user = "rneos", interface = "",
id = 0)
NgetIntermediateResultsNonBlocking(obj = test, convert = TRUE)
}
}
\keyword{IO}
rneos/man/NgetJobStatus.Rd 0000644 0001762 0000144 00000003602 13030210470 015165 0 ustar ligges users \name{NgetJobStatus}
\alias{NgetJobStatus}
\title{
XML-RPC method getJobStatus of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{getJobStatus()} of
NEOS and returns an object of class \code{NeosAns}. The functions
returns the current job status (either \dQuote{Done}, \dQuote{Running},
\dQuote{Waiting}, \dQuote{Unknown Job} or \dQuote{Bad Password}).
}
\usage{
NgetJobStatus(obj, convert = TRUE)
}
\arguments{
\item{obj}{NeosJob, an object of class \code{NeosJob} as returned by
the function \code{NsubmitJob}.}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{NsubmitJob}}
}
\examples{
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
test <- NsubmitJob(xmlstring = xmls, user = "rneos", interface = "",
id = 0)
NgetJobStatus(obj = test, convert = TRUE)
}
}
\keyword{IO}
rneos/man/NeosComm-class.Rd 0000644 0001762 0000144 00000002541 12666402323 015273 0 ustar ligges users \name{NeosComm-class}
\Rdversion{1.1}
\docType{class}
\alias{NeosComm-class}
\title{Class "NeosComm"}
\description{
The purpose of this class is to gather the relevant information needed
for HTTP requests that is passed to NEOS.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("NeosComm", ...)}
or more conveniently by creating an object from \code{CreateNeosComm()}.
}
\section{Slots}{
\describe{
\item{\code{url}:}{Object of class \code{"character"}:
The URL to NEOS, \emph{i.e.}, \url{http://www.neos-server.org}}
\item{\code{curlopts}:}{Object of class \code{"list"}:
A named list of valid Curl options.}
\item{\code{curlhandle}:}{Object of class \code{"CURLHandle"}:
Objects of this class can be created and altered with
\code{getCurlHandle()}}
}
}
\section{Methods}{
No methods defined with class "NeosComm" in the signature.
}
\references{
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl}, and\cr
libcurl web site: \url{http://curl.haxx.se}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\link{CreateNeosComm}}, \code{\link[RCurl]{getCurlHandle}} and
\code{\link[RCurl]{CURLHandle-class}}
}
\examples{
showClass("NeosComm")
\dontrun{
nc <- CreateNeosComm()
nc
}
}
\keyword{classes}
\keyword{IO}
rneos/man/NkillJob.Rd 0000644 0001762 0000144 00000002434 12666402323 014155 0 ustar ligges users \name{NkillJob}
\alias{NkillJob}
\title{
XML-RPC method killJob of Neos
}
\description{
This method is used to cancel a job submission running on NEOS (or
waiting to run on NEOS). The job password is required to prevent abuse
of this function (extracted from relevant slot of \code{obj}). This
functions calls the XML-RPC method \dQuote{killJob()} of NEOS and
returns an object of class \code{NeosAns}.
}
\usage{
NkillJob(obj, killmsg = NULL, convert = TRUE)
}
\arguments{
\item{obj}{Object of class \code{NeosJob}, as returned by the function
\code{NsubmitJob}.}
\item{killmsg}{Character, optional description.}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
}
\value{
An object of class \code{NeosAns} containing the returned message from
NEOS.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\linkS4class{NeosJob}}
}
\keyword{IO}
rneos/man/NgetJobInfo.Rd 0000644 0001762 0000144 00000003405 13030210442 014575 0 ustar ligges users \name{NgetJobInfo}
\alias{NgetJobInfo}
\title{
XML-RPC method getJobInfo of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{getJobInfo()} of NEOS and
returns a four-tuple (category, solver name, input, status).
}
\usage{
NgetJobInfo(obj, convert = TRUE)
}
\arguments{
\item{obj}{Object of class \code{NeosJob}, as returned by the function
\code{NsubmitJob}.}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}}, \code{\linkS4class{NeosJob}}
and \code{\link{NgetJobStatus}}
}
\examples{
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
test <- NsubmitJob(xmlstring = xmls, user = "rneos", interface = "",
id = 0)
NgetJobInfo(obj = test, convert = TRUE)
}
}
\keyword{IO}
rneos/man/NemailHelp.Rd 0000644 0001762 0000144 00000002167 12666402323 014472 0 ustar ligges users \name{NemailHelp}
\alias{NemailHelp}
\title{
XML-RPC method emailHelp of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{emailHelp()} of
NEOS and returns general help message for email users.
}
\usage{
NemailHelp(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
NemailHelp()
}
}
\keyword{IO}
rneos/man/CreateXmlString.Rd 0000644 0001762 0000144 00000003376 13030210704 015514 0 ustar ligges users \name{CreateXmlString}
\alias{CreateXmlString}
\title{
Inserting CDATA into XML-templates of NEOS
}
\description{
With this function the information for XML-templates can be
inserted. Ordinarily, one creates an object with the function
\code{NgetSolverTemplate()} first and then inserts the
requested CDATA fields of this XML-form with this function.
}
\usage{
CreateXmlString(neosxml, cdatalist)
}
\arguments{
\item{neosxml}{An object of class \code{NeosXml} created with the
function \code{NgetSolverTemplate()}.
}
\item{cdatalist}{A named list object with the CDATA tags to be filled.
}
}
\value{A character string containing the specified optimization
problem, which can then be used in a call to \code{NsubmitJob()}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosXml}} and \code{\link{NgetSolverTemplate}}
}
\examples{
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
cat(modc)
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
cat(datc)
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
xmls
}
}
\keyword{IO}
rneos/man/NgetFinalResultsNonBlocking.Rd 0000644 0001762 0000144 00000003662 13030210305 020011 0 ustar ligges users \name{NgetFinalResultsNonBlocking}
\alias{NgetFinalResultsNonBlocking}
\title{
XML-RPC method getFinalResultsNonBlocking of Neos
}
\description{
This functions calls the XML-RPC method
\dQuote{getFinalResultsNonBlocking()} of NEOS, which gets results of a
job submitted to NEOS. If the job is still running, then this function
will return an empty string (base-64 encoded).
}
\usage{
NgetFinalResultsNonBlocking(obj, convert = TRUE)
}
\arguments{
\item{obj}{NeosJob, an object of class \code{NeosJob} as returned by
the function \code{NsubmitJob}.}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned (base-64 encoded).}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{NsubmitJob}}
}
\examples{
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
test <- NsubmitJob(xmlstring = xmls, user = "rneos", interface = "",
id = 0)
NgetFinalResultsNonBlocking(obj = test, convert = TRUE)
}
}
\keyword{IO}
rneos/man/CreateNeosComm.Rd 0000644 0001762 0000144 00000004022 13030206620 015274 0 ustar ligges users \name{CreateNeosComm}
\alias{CreateNeosComm}
\title{
Creating an object for communications with NEOS
}
\description{
This function creates an object of class \code{NeosComm} that will
contain all necessary information for dealing with HTTP requests to
NEOS. This object will be needed in all requests to NEOS and hence
must be created in advance of XML-RPC requests.
}
\usage{
CreateNeosComm(curlopts = list(httpheader = c(`Content-Type` =
"text/xml", `User-Agent` = "R"), port = 3333), curlhandle =
getCurlHandle())
}
\arguments{
\item{curlopts}{A named list of elements that are passed as options to
curl. By default, the \code{httpheader} and the \code{port} options
are preset.}
\item{curlhandle}{An object of class \code{CURLHandle}. By default the
returned object of getCurlHandle() is employed.}
}
\details{
A list of valid \code{curl} options can be retrieved from
\code{listCurlOptions()}. Please note, that the relevant HTTP-bodies
within the requests will be created directly in the API-functions
provided in this package and must not be provided as list elements in
\code{curloptions}. However, if one accesses NEOS \emph{via} a
Proxy-Server, for instance, than the values for the relevant options
must be set within the list-argument \code{curlopts}.
The values of the returned object will be passed down to the function
\code{xml.rpc()} which is utilised for all calls to the function
\code{Nfoo} contained in this package. Hereby, \code{foo} signify the
name of NEOS-API.
}
\value{
An object of class \code{NeosComm}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC},\cr
libcurl web site: \url{http://curl.haxx.se}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosComm}}
}
\examples{
\dontrun{
nc <- CreateNeosComm()
nc
}
}
\keyword{IO}
rneos/man/NgetFinalResults.Rd 0000644 0001762 0000144 00000003543 13030210246 015667 0 ustar ligges users \name{NgetFinalResults}
\alias{NgetFinalResults}
\title{
XML-RPC method getFinalResults of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{getFinalResults()} of
NEOS, which gets results of a job submitted to NEOS. If the job is still
running, then this function will hang until the job is finished.
}
\usage{
NgetFinalResults(obj, convert = TRUE)
}
\arguments{
\item{obj}{NeosJob, an object of class \code{NeosJob} as returned by
the function \code{NsubmitJob}.}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned (base-64 encoded).}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{NsubmitJob}}
}
\examples{
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
test <- NsubmitJob(xmlstring = xmls, user = "rneos", interface = "",
id = 0)
NgetFinalResults(obj = test, convert = TRUE)
}
}
\keyword{IO}
rneos/man/NlistCategories.Rd 0000644 0001762 0000144 00000002324 12666402323 015546 0 ustar ligges users \name{NlistCategories}
\alias{NlistCategories}
\title{
XML-RPC method listCategories of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{listCategories()} of
NEOS and returns an object of class \code{NeosAns}; a dictionary with
entries ('abbreviated name':'full name',...).
}
\usage{
NlistCategories(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
NlistCategories()
}
}
\keyword{IO}
rneos/man/NgetIntermediateResults.Rd 0000644 0001762 0000144 00000004605 13030210332 017244 0 ustar ligges users \name{NgetIntermediateResults}
\alias{NgetIntermediateResults}
\title{
XML-RPC method getIntermediateResults of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{getIntermediateResults()} of
NEOS, which returns intermediate results of a job submitted to NEOS,
starting at the character offset up to the last received
data. Intermediate results are usually the standard output of the
solver daemon. If the job is still running, then this function will
hang until another packet of output is sent to NEOS or the job is
finished. This function will return a tuple of thebase-64 encoded
object and the new offset (object, newoffset). The offset refers to
uncoded characters.
}
\usage{
NgetIntermediateResults(obj, offset = NULL, convert = TRUE)
}
\arguments{
\item{obj}{NeosJob, an object of class \code{NeosJob} as returned by
the function \code{NsubmitJob}.}
\item{offset}{Integer, the offset from which on the results are
returned. In a first run this is set to \code{integer(0)}.}
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned (base-64 encoded).}
}
\value{
An object of class \code{NeosOff}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosOff}} and \code{\link{NsubmitJob}}
}
\examples{
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
test <- NsubmitJob(xmlstring = xmls, user = "rneos", interface = "",
id = 0)
NgetIntermediateResults(obj = test, convert = TRUE)
}
}
\keyword{IO}
rneos/man/Nhelp.Rd 0000644 0001762 0000144 00000002131 12666402323 013511 0 ustar ligges users \name{Nhelp}
\alias{Nhelp}
\title{
XML-RPC method help of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{help()} of NEOS and
returns an object of class \code{NeosAns}.
}
\usage{
Nhelp(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
Nhelp()
}
}
\keyword{IO}
rneos/man/NsubmitJob.Rd 0000644 0001762 0000144 00000002476 13030207130 014514 0 ustar ligges users \name{NsubmitJob}
\alias{NsubmitJob}
\title{
XML-RPC method submitJob of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{submitJob()} of NEOS and
returns an object of class \code{NeosJob}.
}
\usage{
NsubmitJob(xmlstring, user = "rneos", interface = "",
id = 0, nc = CreateNeosComm())
}
\arguments{
\item{xmlstring}{Character, the xml string according to the solver's
template and filled withe the user's optimisation data.}
\item{user}{Character, the name of the user; for certain optimizers an
email address is required.}
\item{interface}{Character, the name of the interface.}
\item{id}{Integer, an identifier for the submitted job.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosJob}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosJob}}, \code{\link{CreateXmlString}} and
\code{\link{NgetSolverTemplate}}
}
\keyword{IO}
rneos/man/NeosXml-class.Rd 0000644 0001762 0000144 00000004471 13030211010 015115 0 ustar ligges users \name{NeosXml-class}
\Rdversion{1.1}
\docType{class}
\alias{NeosXml-class}
\alias{show,NeosXml-method}
\title{Class "NeosXml"}
\description{
Objects of this class contain the returned results from NEOS as well
as information on which kind of query has been sent and how it was sent.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("NeosXml", ...)}
or more conveniently by calling the relevant R API functions.
}
\section{Slots}{
\describe{
\item{\code{xml}:}{Object of class \code{"XMLNode"}:
The returned and converted XML-template of NEOS.}
\item{\code{method}:}{Object of class \code{"character"}:
The name of the called API function.}
\item{\code{call}:}{Object of class \code{"call"}:
The call to the generating function of the object.}
\item{\code{nc}:}{Object of class \code{"NeosComm"}:
The NeosComm object that has been used in the request to NEOS.}
}
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "NeosXml")}: Returns the
converted slot \code{xml} from an object of class \code{NeosXml}.}
}
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosComm}}
}
\examples{
showClass("NeosXml")
\dontrun{
tmp <-NgetSolverTemplate(category = "go", solvername = "ASA",
inputMethod = "AMPL")
## setting path to example model and data file
modf <- system.file("ExAMPL", "diet.mod", package = "rneos")
datf <- system.file("ExAMPL", "diet.dat", package = "rneos")
## import of file contents
modc <- paste(paste(readLines(modf), collapse = "\n"), "\n")
datc <- paste(paste(readLines(datf), collapse = "\n"), "\n")
## create list object
argslist <- list(model = modc, data = datc, commands = "",
comments = "")
## create XML string
xmls <- CreateXmlString(neosxml = tmp, cdatalist = argslist)
test <- NsubmitJob(xmlstring = xmls, user = "rneos", interface = "",
id = 0)
NgetJobStatus(obj = test, convert = TRUE)
NgetJobInfo(obj = test, convert = TRUE)
NgetFinalResults(obj = test, convert = TRUE)
}
}
\keyword{classes}
\keyword{IO}
rneos/man/NlistAllSolvers.Rd 0000644 0001762 0000144 00000002302 12666402323 015543 0 ustar ligges users \name{NlistAllSolvers}
\alias{NlistAllSolvers}
\title{
XML-RPC method listAllSolvers of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{listAllSolvers()} of
NEOS and returns an object of class \code{NeosAns}; a list of
\code{category:solver:inputMethod}.
}
\usage{
NlistAllSolvers(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
NlistAllSolvers()
}
}
\keyword{IO}
rneos/man/Nwelcome.Rd 0000644 0001762 0000144 00000002222 12666402323 014215 0 ustar ligges users \name{Nwelcome}
\alias{Nwelcome}
\title{
XML-RPC method welcome of Neos
}
\description{
This functions calls the XML-RPC method \dQuote{welcome()} of NEOS and
returns an object of class \code{NeosAns}, which is a welcome message
(string).
}
\usage{
Nwelcome(convert = TRUE, nc = CreateNeosComm())
}
\arguments{
\item{convert}{Logical, if \code{convert = TRUE} (the default) the
value of the returned XML-RPC result is extracted and returned as
character, otherwise the XML-RPC string is returned.}
\item{nc}{Object of class \code{NeosComm}:
By default, this argument is set by calling \code{CreateNeosComm()}
and thereby using the default values of this function.}
}
\value{
An object of class \code{NeosAns}.
}
\references{
NEOS API: \url{http://neos-guide.org/content/NEOS-API},\cr
Omegahat web site for RCurl: \url{http://www.omegahat.net/RCurl},\cr
Omegahat web site for XMLRPC: \url{http://www.omegahat.net/XMLRPC}
}
\author{
Bernhard Pfaff
}
\seealso{
\code{\linkS4class{NeosAns}} and \code{\link{CreateNeosComm}}
}
\examples{
\dontrun{
Nwelcome()
}
}
\keyword{IO}