SCM

SCM Repository

[rmetrics] Annotation of /pkg/fPortfolio/R/portfolioConstraints.R
ViewVC logotype

Annotation of /pkg/fPortfolio/R/portfolioConstraints.R

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3286 - (view) (download)

1 : wuertz 1390
2 : wuertz 1195 # This library is free software; you can redistribute it and/or
3 :     # modify it under the terms of the GNU Library General Public
4 :     # License as published by the Free Software Foundation; either
5 :     # version 2 of the License, or (at your option) any later version.
6 :     #
7 :     # This library is distributed in the hope that it will be useful,
8 :     # but WITHOUT ANY WARRANTY; without even the implied warranty of
9 : chalabi 3114 # MERCHANTABILITY or FITNESS FOR A PARTICULAR Description. See the
10 : wuertz 1195 # GNU Library General Public License for more details.
11 :     #
12 : chalabi 3114 # You should have received a copy of the GNU Library General
13 :     # Public License along with this library; if not, write to the
14 :     # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston,
15 : wuertz 1195 # MA 02111-1307 USA
16 :    
17 :     # Copyrights (C)
18 : chalabi 3114 # for this R-port:
19 : wuertz 2864 # 1999 - Diethelm Wuertz, GPL
20 :     # 2007 - Rmetrics Foundation, GPL
21 :     # Diethelm Wuertz <wuertz@itp.phys.ethz.ch>
22 :     # for code accessed (or partly included) from other sources:
23 :     # see Rmetric's copyright and license files
24 : wuertz 1195
25 :    
26 :     ################################################################################
27 : wuertz 1492 # FUNCTION: CONSTRAINTS:
28 :     # portfolioConstraints Checks Consistency of Constraints Strings
29 : wuertz 1578 # FUNCTION: INTERNAL USAGE ONLY:
30 : wuertz 1492 # .setConstraints Transforms constraint strings into a list value
31 :     # .setBoxGroupConstraints Utility function called by .setConstraints()
32 :     # .setRiskBudgetsConstraints Utility function called by .setConstraints()
33 :     # .getConstraints Transforms a constraint list value into strings
34 : wuertz 3250 # .setRdonlp2Constraints Adds Rdonlp2 conform constraints
35 : wuertz 1195 ################################################################################
36 : wuertz 1492
37 : chalabi 3114
38 :     portfolioConstraints <-
39 : wuertz 3250 function(data, spec = portfolioSpec(), constraints = "LongOnly", ...)
40 : chalabi 3114 {
41 : wuertz 2653 # A function implemented by Rmetrics
42 : wuertz 1492
43 :     # Description:
44 :     # Checks Consistency of Constraints Strings
45 : wuertz 2702
46 : wuertz 3250 # Arguments:
47 : wuertz 2840 # data - a portfolio data object
48 :     # spec - a portfolio specification object
49 :     # constraints - a constraints string
50 : wuertz 3286
51 :     # Example:
52 :     # Data = as.timeSeries(data(LPP2005REC))[, 1:6]
53 :     # Spec = portfolioSpec()
54 :     # Constraints = c("minW[1:6]=0.1", "maxW[1:6]=0.9", "minsumW[1:6]=0.1", "maxsumW[1:6]=0.9")
55 :     # portfolioConstraints(Data, Spec, Constraints)
56 :    
57 : wuertz 1578 # FUNCTION:
58 : chalabi 3114
59 : wuertz 3250 # Handle NULL:
60 :     if (is.null(constraints)) constraints = "LongOnly"
61 :    
62 :     # Already done ...
63 :     if (class(constraints) == "fPFOLIOCON") return(constraints)
64 :    
65 :     # Constraints is a string (vector) ...
66 :    
67 : wuertz 1492 # Vector of Valid Strings:
68 : chalabi 3114 validStrings = c(
69 : wuertz 1578 "LongOnly", "Short", # LongOnly and Short Notification
70 :     "minW", "maxW", # Box Constraints
71 : wuertz 3286 "sumW", # Two Sided Group Constraints
72 :     "minsumW", "maxsumW", # left and right Sided Group Constraints
73 : wuertz 3250 "minB", "maxB", # Covariance Risk Budgets
74 :     "rdonlp2") # alt Rdonlp2 Constraints
75 : chalabi 3114
76 : wuertz 2702 # Check Constraints Strings:
77 : wuertz 1492 usedStrings = unique(sort(sub("\\[.*", "", constraints)))
78 :     checkStrings = usedStrings %in% validStrings
79 :     check = (sum(!checkStrings) == 0)
80 : wuertz 3250 if (check) {
81 :     check = "valid"
82 :     } else {
83 :     stop("Unvalid Constraints String(s)")
84 :     }
85 : wuertz 2702 stringConstraints = constraints
86 :     attr(stringConstraints, "control") = check
87 : chalabi 3114
88 : wuertz 3286 # Set Box Constraints:
89 :     boxConstraints = .setBoxConstraints(data, spec, constraints)
90 :    
91 :     # Set Group Equal Constraints:
92 :     groupEqConstraints = .setGroupEqConstraints(data, spec, constraints)
93 :    
94 :     # Set Group Matrix Constraints:
95 :     groupMatConstraints = .setGroupMatConstraints(data, spec, constraints)
96 :    
97 : wuertz 3250 # Set BoxGroup Constraints:
98 : chalabi 3114 boxgroupConstraints =
99 : wuertz 2702 .setConstraints(data, spec, constraints, type = "BoxGroup")
100 : chalabi 3114
101 : wuertz 3250 # Set RiskBudget Constraints:
102 : chalabi 3114 riskbudgetConstraints =
103 : wuertz 2702 .setConstraints(data, spec, constraints, type = "RiskBudget")
104 : wuertz 3250
105 :     # Alternative Constraints Settings:
106 :     # This allows to set directly constraints for the rdonlp2 solver.
107 :     # Note, arguments are passed through the dots argument.
108 :     if (constraints[1] == "rdonlp2") {
109 :     rdonlp2Constraints = .setRdonlp2Constraints(data, spec, ...)
110 :     } else {
111 :     rdonlp2Constraints = list()
112 :     }
113 : chalabi 3114
114 : wuertz 1492 # Return Value:
115 : wuertz 2702 new("fPFOLIOCON",
116 :     stringConstraints = stringConstraints,
117 : wuertz 3286 boxConstraints = boxConstraints,
118 :     groupEqConstraints = groupEqConstraints,
119 :     groupMatConstraints = groupMatConstraints,
120 : wuertz 2702 boxgroupConstraints = boxgroupConstraints,
121 : wuertz 3250 riskbudgetConstraints = riskbudgetConstraints,
122 :     altConstraints = rdonlp2Constraints)
123 : wuertz 1492 }
124 :    
125 :    
126 :     # ------------------------------------------------------------------------------
127 :    
128 :    
129 : chalabi 3114 .setConstraints <-
130 : wuertz 2702 function(data, spec = portfolioSpec(), constraints = "LongOnly",
131 : wuertz 2653 type = c("BoxGroup", "RiskBudget"))
132 : chalabi 3114 {
133 : wuertz 2653 # A function implemented by Rmetrics
134 : wuertz 1492
135 :     # Description:
136 :     # Transforms constraint strings into a list value
137 : chalabi 3114
138 : wuertz 1492 # Arguments:
139 : wuertz 3250 # data - a portfolio data object
140 :     # spec - a portfolio specification object
141 :     # constraints - a constraints string
142 :     # type - type of constraints
143 : chalabi 3114
144 : wuertz 1492 # FUNCTION:
145 : chalabi 3114
146 : wuertz 1492 # Check Arguments:
147 :     type = match.arg(type)
148 : chalabi 3114
149 : wuertz 1492 # Check Data:
150 : wuertz 3250 data = portfolioData(data, spec)
151 : chalabi 3114
152 : wuertz 1492 # Short Selling:
153 : wuertz 3250 ## DW: I'm not sure if we need this
154 :     ## if (any(constraints == "Short")) constraints = NULL
155 : chalabi 3114
156 : chalabi 3151 # check if user want to use Risk Budget with wrong solver
157 :     # currently only Rdonlp2 supports Risk Budget constraints
158 :     if (length(grep("minB|maxB", constraints)) &&
159 :     getSolver(spec) != "solveRdonlp2")
160 :     warning("Risk budget used with wrong solver")
161 :    
162 : wuertz 1492 # Constraints:
163 :     if (type == "BoxGroup") {
164 :     ans = .setBoxGroupConstraints(data, spec, constraints)
165 :     } else if (type == "RiskBudget") {
166 :     ans = .setRiskBudgetsConstraints(data, spec, constraints)
167 :     }
168 : chalabi 3114
169 : wuertz 1492 # Return Value:
170 :     ans
171 :     }
172 :    
173 :    
174 :     # ------------------------------------------------------------------------------
175 :    
176 :    
177 : chalabi 3114 .setBoxGroupConstraints <-
178 : wuertz 2702 function(data, spec = portfolioSpec(), constraints = "LongOnly")
179 : chalabi 3114 {
180 : wuertz 2653 # A function implemented by Rmetrics
181 : wuertz 1195
182 :     # Description:
183 :     # Transforms constraint strings into a list value
184 : chalabi 3114
185 : wuertz 1195 # Arguments:
186 : wuertz 3250 # data - a portfolio data object
187 :     # spec - a portfolio specification object
188 :     # constraints - a constraints string
189 :     # type - type of constraints
190 : chalabi 3114
191 : wuertz 1195 # FUNCTION:
192 : chalabi 3114
193 : wuertz 1195 # Get Statistics:
194 : wuertz 3250 data = portfolioData(data, spec)
195 : chalabi 3114
196 : wuertz 1589 # Get Specifications:
197 : chalabi 3114 mu = getMu(data)
198 : wuertz 1589 Sigma = getSigma(data)
199 : wuertz 2676 N = nAssets = getNAssets(data)
200 : chalabi 3114 nameAssets <- getNames(data)
201 :    
202 : wuertz 1195 # Target Return:
203 : chalabi 3114 targetReturn = getTargetReturn(spec)
204 : wuertz 1589 weights = getWeights(spec)
205 : wuertz 1195 if(is.null(targetReturn) & is.null(weights)) {
206 :     weights = rep(1/N, N)
207 : wuertz 1492 # warning("Equal Weights Portfolio in use")
208 : wuertz 1195 }
209 :     if(is.null(targetReturn)) {
210 :     targetReturn = (weights %*% Sigma %*% weights)[1, 1]
211 :     }
212 :    
213 :     # Compose Matrix A:
214 : chalabi 3114 A = matrix(c(rep(1, times = N), mu), byrow = TRUE, ncol = N)
215 : wuertz 1195 A = rbind(A, diag(1, N), diag(-1, N))
216 : chalabi 3114 # colnames(A) = paste("A", 1:N, sep = "")
217 :     colnames(A) <- nameAssets
218 :     rownames(A) = c("Budget", "Return", paste("minW", 1:N, sep = ""),
219 : wuertz 1195 paste("maxW", 1:N, sep = ""))
220 :    
221 :     # Compose vector b0:
222 :     minW = rep(0, N)
223 :     maxW = rep(1, N)
224 : chalabi 3114 names(minW) <- names(maxW) <- nameAssets
225 : wuertz 1195 b0 = matrix(c(1, targetReturn, minW, -maxW), ncol = 1)
226 :     colnames(b0) = "b0"
227 : wuertz 1393 if (!is.null(constraints)) {
228 :     nC = length(constraints)
229 :     what = substr(constraints, 1, 4)
230 : chalabi 3114 for (i in 1:nC) {
231 : wuertz 1195 if (what[i] == "minW" | what[i] == "maxW") {
232 : wuertz 1393 eval(parse(text = constraints[i]))
233 : wuertz 1195 }
234 : chalabi 3114 }
235 :     b0 = matrix(c(1, targetReturn, minW, -maxW), ncol = 1)
236 : wuertz 1393 what = substr(constraints, 1, 7)
237 : chalabi 3114 for (i in 1:nC) {
238 : wuertz 1195 if (what[i] == "minsumW") {
239 :     minsumW = rep(0, times = N)
240 : chalabi 3114 names(minsumW) <- nameAssets
241 : wuertz 1393 eval(parse(text = constraints[i]))
242 : chalabi 3114 A = rbind(A, minsumW = sign(minsumW))
243 : wuertz 1393 b = strsplit(constraints[i], "=")[[1]][2]
244 : wuertz 1195 b0 = rbind(b0, as.numeric(b))
245 :     }
246 :     }
247 : chalabi 3114 for (i in 1:nC) {
248 : wuertz 1195 if (what[i] == "maxsumW") {
249 :     maxsumW = rep(0, times = N)
250 : chalabi 3114 names(maxsumW) <- nameAssets
251 : wuertz 1393 eval(parse(text = constraints[i]))
252 : chalabi 3114 A = rbind(A, maxsumW = -sign(maxsumW))
253 : wuertz 1393 b = strsplit(constraints[i], "=")[[1]][2]
254 : wuertz 1195 b0 = rbind(b0, -as.numeric(b))
255 :     }
256 :     }
257 :     }
258 :     rownames(b0) = rownames(A)
259 : chalabi 3114
260 : wuertz 1492 # Bind Results:
261 : wuertz 1195 ans = cbind(A = A, b = b0)
262 :     colnames(ans) = c(colnames(A), "Exposure")
263 : wuertz 2840 class(ans) = "matrix"
264 : chalabi 3114
265 : wuertz 1195 # Return Value:
266 :     ans
267 :     }
268 :    
269 :    
270 : wuertz 1492 # ------------------------------------------------------------------------------
271 : wuertz 1195
272 :    
273 : wuertz 3286 .setBoxConstraints <-
274 :     function(data, spec = portfolioSpec(), constraints = "LongOnly")
275 :     {
276 :     # A function implemented by Rmetrics
277 :    
278 :     # Description:
279 :     # Transforms constraint strings into minW and maxW vectors
280 :    
281 :     # Arguments:
282 :     # data - a portfolio data object
283 :     # spec - a portfolio specification object
284 :     # constraints - a constraints string
285 :     # type - type of constraints
286 :    
287 :     # FUNCTION:
288 :    
289 :     # Get Statistics:
290 :     data = portfolioData(data, spec)
291 :    
292 :     # Get Specifications:
293 :     N = nAssets = getNAssets(data)
294 :     nameAssets <- getNames(data)
295 :    
296 :     # Compose vectors avec and bvec:
297 :     minW = rep(0, N)
298 :     maxW = rep(1, N)
299 :     names(minW) <- names(maxW) <- nameAssets
300 :     if (!is.null(constraints)) {
301 :     nC = length(constraints)
302 :     what = substr(constraints, 1, 4)
303 :     for (i in 1:nC) {
304 :     if (what[i] == "minW" | what[i] == "maxW") {
305 :     eval(parse(text = constraints[i]))
306 :     }
307 :     }
308 :     }
309 :    
310 :     # Return Value:
311 :     list(minW = minW, maxW = maxW)
312 :     }
313 :    
314 :    
315 :     # ------------------------------------------------------------------------------
316 :    
317 :    
318 :     .setGroupEqConstraints <-
319 :     function(data, spec = portfolioSpec(), constraints = "LongOnly")
320 :     {
321 :     # A function implemented by Rmetrics
322 :    
323 :     # Description:
324 :     # Transforms constraint strings into a list value
325 :    
326 :     # Arguments:
327 :     # data - a portfolio data object
328 :     # spec - a portfolio specification object
329 :     # constraints - a constraints string
330 :     # type - type of constraints
331 :    
332 :     # FUNCTION:
333 :    
334 :     # Get Statistics:
335 :     data = portfolioData(data, spec)
336 :     targetReturn =
337 :     if(is.null(getTargetReturn(spec))) targetReturn = NA
338 :     else targetReturn = getTargetReturn(spec)
339 :    
340 :     # Get Specifications:
341 :     mu = getMu(data)
342 :     N = nAssets = getNAssets(data)
343 :     nameAssets <- getNames(data)
344 :    
345 :     # Target Return:
346 :     Aeq = matrix(mu, byrow = TRUE, ncol = N)
347 :     # Full Investment:
348 :     Aeq = rbind(Aeq, rep(1, N))
349 :     # Dimension Names:
350 :     colnames(Aeq) <- nameAssets
351 :     rownames(Aeq) = c("Return", "Budget")
352 :     ceq = c(Return = targetReturn, Budget = 1)
353 :    
354 :     # Return Value:
355 :     list(Aeq = Aeq, ceq = ceq)
356 :     }
357 :    
358 :    
359 :     # ------------------------------------------------------------------------------
360 :    
361 :    
362 :     .setGroupMatConstraints <-
363 :     function(data, spec = portfolioSpec(), constraints = "LongOnly")
364 :     {
365 :     # A function implemented by Rmetrics
366 :    
367 :     # Description:
368 :     # Transforms constraint strings into a list value
369 :    
370 :     # Arguments:
371 :     # data - a portfolio data object
372 :     # spec - a portfolio specification object
373 :     # constraints - a constraints string
374 :     # type - type of constraints
375 :    
376 :     # Example:
377 :     # data = as.timeSeries(data(LPP2005REC))[, 1:6]
378 :     # spec = portfolioSpec()
379 :     # constraints = c("minsumW[3:5]=0.1", "maxsumW[1:3]=0.8", "sumW[4]=c(0.2,0.7)")
380 :    
381 :    
382 :     # FUNCTION:
383 :    
384 :     # Get Statistics:
385 :     data = portfolioData(data, spec)
386 :    
387 :     # Get Specifications:
388 :     N = nAssets = getNAssets(data)
389 :     nameAssets <- getNames(data)
390 :    
391 :     # Compose matrix Amat and vectors avec and bvec:
392 :     Amat = matrix(rep(1, N), nrow = 1)
393 :     avec = matrix(-Inf)
394 :     bvec = matrix(Inf)
395 :     what4 = substr(constraints, 1, 4)
396 :     what7 = substr(constraints, 1, 7)
397 :     count = 0
398 :     if (!is.null(constraints)) {
399 :     nC = length(constraints)
400 :     for (i in 1:nC) {
401 :     if (what7[i] == "minsumW") {
402 :     count = count + 1
403 :     minsumW = rep(0, times = N)
404 :     names(minsumW) <- nameAssets
405 :     eval(parse(text = constraints[i]))
406 :     Amat = rbind(Amat, minsumW = sign(minsumW))
407 :     a = strsplit(constraints[i], "=")[[1]][2]
408 :     avec = rbind(avec, as.numeric(a))
409 :     bvec = rbind(bvec, +Inf)
410 :     }
411 :     }
412 :     for (i in 1:nC) {
413 :     if (what7[i] == "maxsumW") {
414 :     count = count + 1
415 :     maxsumW = rep(0, times = N)
416 :     names(maxsumW) <- nameAssets
417 :     eval(parse(text = constraints[i]))
418 :     Amat = rbind(Amat, maxsumW = sign(maxsumW))
419 :     b = strsplit(constraints[i], "=")[[1]][2]
420 :     avec = rbind(avec, -Inf)
421 :     bvec = rbind(bvec, as.numeric(b))
422 :     }
423 :     }
424 :     for (i in 1:nC) {
425 :     if (what4[i] == "sumW") {
426 :     count = count + 1
427 :     sumW = rep(0, times = N)
428 :     names(sumW) <- nameAssets
429 :     A = paste(strsplit(constraints[i], "=")[[1]][1], "=1")
430 :     eval(parse(text = A))
431 :     Amat = rbind(Amat, sumW = sign(sumW))
432 :     b = paste("MinMax =", strsplit(constraints[i], "=")[[1]][2])
433 :     eval(parse(text = b))
434 :     avec = rbind(avec, MinMax[1])
435 :     bvec = rbind(bvec, MinMax[2])
436 :     }
437 :     }
438 :     }
439 :     if (count > 0) {
440 :     Amat = Amat[-1, ]
441 :     avec = matrix(avec[-1, ])
442 :     bvec = matrix(bvec[-1, ])
443 :     }
444 :     rownames(avec) <- rownames(Amat)
445 :     rownames(bvec) <- rownames(Amat)
446 :     colnames(avec) <- "lower"
447 :     colnames(bvec) <- "upper"
448 :    
449 :     # Return Value:
450 :     list(Amat = Amat, avec = avec, bvec = bvec)
451 :     }
452 :    
453 :    
454 :     # ------------------------------------------------------------------------------
455 :    
456 :    
457 : chalabi 3114 .setRiskBudgetsConstraints <-
458 : wuertz 2702 function(data, spec = NULL, constraints = "LongOnly")
459 : chalabi 3114 {
460 : wuertz 2653 # A function implemented by Rmetrics
461 : wuertz 1195
462 : wuertz 1492 # Description:
463 :     # Transforms constraint strings into a list value
464 : chalabi 3114
465 : wuertz 1492 # Arguments:
466 : chalabi 3114
467 : wuertz 1492 # Example:
468 :     # Constraints = c("minB[3:4]=0.1","maxB[1:3]=0.3","maxB[c(4,6)]=0.4")
469 :     # setRiskBudgetsConstraints(8, constraints = Constraints)
470 : chalabi 3114
471 : wuertz 1492 # FUNCTION:
472 : chalabi 3114
473 : wuertz 1589 # Create Data Object:
474 : wuertz 3250 data = portfolioData(data, spec)
475 : chalabi 3114
476 : wuertz 1589 # Get Specifications:
477 : chalabi 3114 mu = getMu(data)
478 : wuertz 1589 Sigma = getSigma(data)
479 : wuertz 2676 N = nAssets = getNAssets(data)
480 : chalabi 3114 nameAssets <- getNames(data)
481 :    
482 : wuertz 1492 # Compose Risk Budgets:
483 :     minB = rep(0, N)
484 :     maxB = rep(1, N)
485 : chalabi 3114 names(minB) <- names(maxB) <- nameAssets
486 : wuertz 1492 if (!is.null(constraints)) {
487 :     nC = length(constraints)
488 :     what = substr(constraints, 1, 4)
489 : chalabi 3114 for (i in 1:nC) {
490 : wuertz 1492 if (what[i] == "minB" | what[i] == "maxB") {
491 :     eval(parse(text = constraints[i]))
492 :     }
493 : chalabi 3114 }
494 : wuertz 1492 }
495 :     ans = rbind(minB = minB, maxB = maxB)
496 : chalabi 3114 # colnames(ans) = paste("A", 1:N, sep = "")
497 :    
498 : wuertz 1492 # Return Value:
499 :     ans
500 : wuertz 1195 }
501 :    
502 :    
503 : wuertz 1492 ################################################################################
504 : wuertz 1195
505 :    
506 : chalabi 3114 .getConstraints <-
507 : wuertz 2653 function(object)
508 : chalabi 3114 {
509 : wuertz 2653 # A function implemented by Rmetrics
510 : wuertz 1195
511 :     # Description:
512 :     # Transforms a constraint list value into strings
513 : chalabi 3114
514 : wuertz 1195 # Arguments:
515 : chalabi 3114 # object - the "constraintMatrix", a list with two named elements,
516 : wuertz 1578 # the constrainded Matrix A and the constrained vector b, satisfying
517 : wuertz 2676 # A * w >= b, where b is the exosure.
518 : chalabi 3114
519 : wuertz 1195 # Value:
520 :     # A one column matrix with constraint strings.
521 : chalabi 3114
522 : wuertz 1195 # FUNCTION:
523 : chalabi 3114
524 : wuertz 1195 # Extract Matrix A and Vector b0:
525 :     M = dim(object)[2]
526 :     A = object[, -M]
527 :     b0 = t(t(object[, M]))
528 : chalabi 3114
529 : wuertz 1195 # Matrix Dimension:
530 :     L = dim(A)[1]
531 : chalabi 3114 N = dim(A)[2]
532 :    
533 : wuertz 1195 # Start with Box Constraints:
534 :     const1 = paste("minW[", 1:N, "] = ", b0[3:(2+N),], sep = "")
535 :     const2 = paste("maxW[", 1:N, "] = ", -b0[(3+N):(2+2*N),], sep = "")
536 : wuertz 1393 constraints = matrix(c(const1, const2), ncol = 1)
537 : chalabi 3114
538 : wuertz 1195 # Add Sector Constraints:
539 :     if((3+2*N) <= L) {
540 :     for (i in (3+2*N):L) {
541 :     index = paste ((1:N)[abs(A[i, ]) != 0], collapse = ",")
542 : chalabi 3114 addConstraintString = paste(rownames(A)[i], "[c(", index, ")] = ",
543 : wuertz 1195 abs(b0[i]), sep = "")
544 : wuertz 1393 constraints = rbind(constraints, addConstraintString)
545 : wuertz 1195 }
546 :     }
547 : chalabi 3114
548 : wuertz 1195 # Add Names:
549 : wuertz 1393 colnames(constraints) = "Constraints"
550 :     rownames(constraints) = 1:(L-2)
551 : chalabi 3114
552 : wuertz 1195 # Return Value:
553 : wuertz 1393 constraints
554 : wuertz 1195 }
555 :    
556 :    
557 : wuertz 3250 # ------------------------------------------------------------------------------
558 :    
559 :    
560 :     .setRdonlp2Constraints <-
561 :     function(data, spec,
562 :     par.lower = NULL, par.upper = NULL,
563 :     A = NULL, lin.lower = NULL, lin.upper = NULL,
564 :     nlin = list(), nlin.lower = NULL, nlin.upper = NULL)
565 :     {
566 :     # A function implemented by Rmetrics
567 :    
568 :     # Description:
569 :     # Adds Rdonlp2 conform constraints
570 :    
571 :     # Arguments:
572 :     # Here we use the same arguments as in the original Rdonlp2
573 :     # package ...
574 :    
575 :     # Defaults for "LongOnly"
576 :     if (is.null(par.lower)) par.lower = rep(0, times = NCOL(data))
577 :     if (is.null(par.upper)) par.upper = rep(1, times = NCOL(data))
578 :    
579 :     # Return Value:
580 :     list(
581 :     name = "solveRdonlp2",
582 :     par.lower = par.lower, par.upper = par.upper,
583 :     A = A, lin.lower = lin.lower, lin.upper = lin.upper,
584 :     nlin = nlin, nlin.lower = nlin.lower, nlin.upper = nlin.upper)
585 :     }
586 :    
587 :    
588 : wuertz 1195 ################################################################################
589 :    
590 : wuertz 3286
591 :     .setRquadprogConstraints <-
592 :     function(data, spec, constraints)
593 :     {
594 :     # FUNCTION:
595 :    
596 :     # Setting the constraints matrix and vector:
597 :     data = portfolioData(data, spec)
598 :     if (class(constraints) == "fPFOLIOCON")
599 :     constraints = constraints@stringConstraints
600 :     tmpConstraints = .setConstraints(data, spec, constraints)
601 :     nAssets = getNAssets(data)
602 :     Sigma = getSigma(data)
603 :    
604 :     # Arguments:
605 :     Dmat = Sigma
606 :     dvec = rep(0, nAssets)
607 :     Amat = t(tmpConstraints[, -(nAssets+1)])
608 :     bvec = tmpConstraints[, (nAssets+1)]
609 :     meq = 2
610 :    
611 :     # Return Value"
612 :     list(Dmat = Dmat, dvec = dvec, Amat = Amat, bvec = bvec, meq = meq)
613 :     }
614 :    
615 :    
616 :     # ------------------------------------------------------------------------------

R-Forge@R-project.org
ViewVC Help
Powered by ViewVC 1.0.0  
Thanks to:
Vienna University of Economics and Business University of Wisconsin - Madison Powered By FusionForge