[Robast-commits] r1262 - in pkg/RandVar: . inst man tests tests/Examples

noreply at r-forge.r-project.org noreply at r-forge.r-project.org
Tue Jan 30 16:45:57 CET 2024


Author: stamats
Date: 2024-01-30 16:45:57 +0100 (Tue, 30 Jan 2024)
New Revision: 1262

Modified:
   pkg/RandVar/DESCRIPTION
   pkg/RandVar/inst/NEWS
   pkg/RandVar/man/0RandVar-package.Rd
   pkg/RandVar/tests/Examples/RandVar-Ex.Rout.save
   pkg/RandVar/tests/tests.Rout.save
Log:
prepared release of version 1.2.2

Modified: pkg/RandVar/DESCRIPTION
===================================================================
--- pkg/RandVar/DESCRIPTION	2024-01-28 20:11:52 UTC (rev 1261)
+++ pkg/RandVar/DESCRIPTION	2024-01-30 15:45:57 UTC (rev 1262)
@@ -1,6 +1,6 @@
 Package: RandVar
 Version: 1.2.2
-Date: 2023-05-08
+Date: 2024-01-30
 Title: Implementation of Random Variables
 Description: Implements random variables by means of S4 classes and methods.
 Depends: R(>= 3.4), methods, distr(>= 2.8.0), distrEx(>= 2.8.0)

Modified: pkg/RandVar/inst/NEWS
===================================================================
--- pkg/RandVar/inst/NEWS	2024-01-28 20:11:52 UTC (rev 1261)
+++ pkg/RandVar/inst/NEWS	2024-01-30 15:45:57 UTC (rev 1262)
@@ -7,19 +7,13 @@
  RobAStXXX family as a whole in order to ease updating "depends" 
  information)
 
-#######################################
-version 1.3
-#######################################
 
-user-visible CHANGES:
-+ CITATION file now uses bibentry.
-
-
 #######################################
 version 1.2
 #######################################
 
 user-visible CHANGES:
++ CITATION file now uses bibentry.
 + require more recent distr/distrEx versions
 + E methods for RandVariables gain argument diagnostic
   (like E()-methods in distrEx v 2.8.0)

Modified: pkg/RandVar/man/0RandVar-package.Rd
===================================================================
--- pkg/RandVar/man/0RandVar-package.Rd	2024-01-28 20:11:52 UTC (rev 1261)
+++ pkg/RandVar/man/0RandVar-package.Rd	2024-01-30 15:45:57 UTC (rev 1262)
@@ -12,13 +12,12 @@
 \tabular{ll}{
 Package: \tab RandVar \cr
 Version: \tab 1.2.2 \cr
-Date: \tab 2023-05-08 \cr
+Date: \tab 2024-01-30 \cr
 Depends: \tab R(>= 3.4), methods, distr(>= 2.8.0), distrEx(>= 2.8.0) \cr
 Imports: \tab startupmsg \cr
 ByteCompile: \tab yes \cr
 License: \tab LGPL-3 \cr
 URL: \tab https://r-forge.r-project.org/projects/robast/\cr
-VCS/SVNRevision: \tab 1228 \cr
 }
 }
 \author{

Modified: pkg/RandVar/tests/Examples/RandVar-Ex.Rout.save
===================================================================
--- pkg/RandVar/tests/Examples/RandVar-Ex.Rout.save	2024-01-28 20:11:52 UTC (rev 1261)
+++ pkg/RandVar/tests/Examples/RandVar-Ex.Rout.save	2024-01-30 15:45:57 UTC (rev 1262)
@@ -1,2418 +1,2466 @@
-
-R Under development (unstable) (2019-02-27 r76167) -- "Unsuffered Consequences"
-Copyright (C) 2019 The R Foundation for Statistical Computing
-Platform: i386-w64-mingw32/i386 (32-bit)
-
-R is free software and comes with ABSOLUTELY NO WARRANTY.
-You are welcome to redistribute it under certain conditions.
-Type 'license()' or 'licence()' for distribution details.
-
-  Natural language support but running in an English locale
-
-R is a collaborative project with many contributors.
-Type 'contributors()' for more information and
-'citation()' on how to cite R or R packages in publications.
-
-Type 'demo()' for some demos, 'help()' for on-line help, or
-'help.start()' for an HTML browser interface to help.
-Type 'q()' to quit R.
-
-> pkgname <- "RandVar"
-> source(file.path(R.home("share"), "R", "examples-header.R"))
-> options(warn = 1)
-> options(pager = "console")
-> library('RandVar')
-Loading required package: distr
-Loading required package: startupmsg
-:startupmsg>  Utilities for Start-Up Messages (version 0.9.6)
-:startupmsg> 
-:startupmsg>  For more information see ?"startupmsg",
-:startupmsg>  NEWS("startupmsg")
-
-Loading required package: sfsmisc
-:distr>  Object Oriented Implementation of Distributions (version
-:distr>  2.8.0)
-:distr> 
-:distr>  Attention: Arithmetics on distribution objects are
-:distr>  understood as operations on corresponding random variables
-:distr>  (r.v.s); see distrARITH().
-:distr> 
-:distr>  Some functions from package 'stats' are intentionally masked
-:distr>  ---see distrMASK().
-:distr> 
-:distr>  Note that global options are controlled by distroptions()
-:distr>  ---c.f. ?"distroptions".
-:distr> 
-:distr>  For more information see ?"distr", NEWS("distr"), as well as
-:distr>    http://distr.r-forge.r-project.org/
-:distr>  Package "distrDoc" provides a vignette to this package as
-:distr>  well as to several extension packages; try
-:distr>  vignette("distr").
-
-
-Attaching package: 'distr'
-
-The following objects are masked from 'package:stats':
-
-    df, qqplot, sd
-
-Loading required package: distrEx
-:distrEx>  Extensions of Package 'distr' (version 2.8.0)
-:distrEx> 
-:distrEx>  Note: Packages "e1071", "moments", "fBasics" should be
-:distrEx>  attached /before/ package "distrEx". See
-:distrEx>  distrExMASK().Note: Extreme value distribution
-:distrEx>  functionality has been moved to
-:distrEx> 
-:distrEx>        package "RobExtremes". See distrExMOVED().
-:distrEx> 
-:distrEx>  For more information see ?"distrEx", NEWS("distrEx"), as
-:distrEx>  well as
-:distrEx>    http://distr.r-forge.r-project.org/
-:distrEx>  Package "distrDoc" provides a vignette to this package
-:distrEx>  as well as to several related packages; try
-:distrEx>  vignette("distr").
-
-
-Attaching package: 'distrEx'
-
-The following objects are masked from 'package:stats':
-
-    IQR, mad, median, var
-
-:RandVar>  Implementation of Random Variables (version 1.2.0)
-:RandVar> 
-:RandVar>  For more information see ?"RandVar", NEWS("RandVar"), as
-:RandVar>  well as
-:RandVar>    http://robast.r-forge.r-project.org/
-:RandVar>  This package also includes a vignette; try
-:RandVar>  vignette("RandVar").
-
-> 
-> base::assign(".oldSearch", base::search(), pos = 'CheckExEnv')
-> base::assign(".old_wd", base::getwd(), pos = 'CheckExEnv')
-> cleanEx()
-> nameEx("0RandVar-package")
-> ### * 0RandVar-package
-> 
-> flush(stderr()); flush(stdout())
-> 
-> ### Name: RandVar-package
-> ### Title: Implementation of Random Variables
-> ### Aliases: RandVar-package RandVar
-> ### Keywords: package
-> 
-> ### ** Examples
-> 
-> library(RandVar)
-> #vignette("RandVar")
-> 
-> 
-> 
-> cleanEx()
-> nameEx("EuclRandMatrix-class")
-> ### * EuclRandMatrix-class
-> 
-> flush(stderr()); flush(stdout())
-> 
-> ### Name: EuclRandMatrix-class
-> ### Title: Euclidean random matrix
-> ### Aliases: EuclRandMatrix-class
-> ###   coerce,EuclRandMatrix,EuclRandVarList-method Dim
-> ###   Dim,EuclRandMatrix-method Dim<- Dim<-,EuclRandMatrix-method
-> ###   [,EuclRandMatrix-method ncol,EuclRandMatrix-method
-> ###   nrow,EuclRandMatrix-method dimension,EuclRandMatrix-method
-> ###   evalRandVar,EuclRandMatrix,numeric,missing-method
-> ###   evalRandVar,EuclRandMatrix,matrix,missing-method
-> ###   evalRandVar,EuclRandMatrix,numeric,Distribution-method
-> ###   evalRandVar,EuclRandMatrix,matrix,Distribution-method
-> ###   t,EuclRandMatrix-method show,EuclRandMatrix-method
-> ###   %*%,matrix,EuclRandMatrix-method %*%,numeric,EuclRandMatrix-method
-> ###   %*%,EuclRandMatrix,matrix-method %*%,EuclRandMatrix,numeric-method
-> ###   %*%,EuclRandMatrix,EuclRandMatrix-method
-> ###   Arith,numeric,EuclRandMatrix-method
-> ###   Arith,EuclRandMatrix,numeric-method
-> ###   Arith,EuclRandMatrix,EuclRandMatrix-method Math,EuclRandMatrix-method
-> ###   E,UnivariateDistribution,EuclRandMatrix,missing-method
-> ###   E,AbscontDistribution,EuclRandMatrix,missing-method
-> ###   E,DiscreteDistribution,EuclRandMatrix,missing-method
-> ###   E,MultivariateDistribution,EuclRandMatrix,missing-method
-> ###   E,DiscreteMVDistribution,EuclRandMatrix,missing-method
-> ###   E,UnivariateCondDistribution,EuclRandMatrix,numeric-method
-> ###   E,AbscontCondDistribution,EuclRandMatrix,numeric-method
-> ###   E,DiscreteCondDistribution,EuclRandMatrix,numeric-method
-> ### Keywords: classes arith math
-> 
-> ### ** Examples
-> 
-> L1 <- list(function(x){x}, function(x){x^2}, function(x){x^3}, function(x){x^4}, 
-+            function(x){x^5}, function(x){x^6})
-> L2 <- list(function(x){exp(x)}, function(x){abs(x)}, 
-+            function(x){sin(x)}, function(x){floor(x)})
-> 
-> R1 <- new("EuclRandMatrix", Map = L1, Dim = as.integer(c(3,2)), 
-+                             Domain = Reals(), Range = Reals())
-> dimension(R1)
-[1] 6
-> R1[1:2, 2]
-An object of class "EuclRandVariable" 
-length of Map:	 2 
-Domain:	Real Space with dimension 1 
-Range:	Real Space with dimension 1 
-> R1[1:2, 1:2]
-An object of class "EuclRandMatrix" 
-Dim of Map:	 2 2 
-Domain:	Real Space with dimension 1 
-Range:	Real Space with dimension 1 
-> Map(R1[1,2])
-[[1]]
-function (x) 
-{
-    x^4
-}
-
-> Map(t(R1)[2,1])
-[[1]]
-function (x) 
-{
-    f <- function (x) 
-    {
-        x^4
-    }
-    t(f(x))
-}
-<environment: 0x08320e98>
-
-> 
-> R2 <- EuclRandMatrix(Map = L2, ncol = 2, Domain = Reals(), dimension = 1)
-> dimension(R2)
-[1] 4
-> (DL <- imageDistr(R2, Norm()))
-An object of class "DistrList"
- [[1]] Distribution Object of Class: AbscontDistribution
- [[2]] Distribution Object of Class: AbscontDistribution
- [[3]] Distribution Object of Class: AbscontDistribution
- [[4]] Distribution Object of Class: AbscontDistribution
-Warning in (new("standardGeneric", .Data = function (object)  :
-  arithmetics on distributions are understood as operations on r.v.'s
-see 'distrARITH()'; for switching off this warning see '?distroptions'
-Warning in (new("standardGeneric", .Data = function (object)  :
-  slots d,p,q have been filled using simulations; for switching off this warning see '?distroptions'
-> plot(DL)
-> 
-> Map(gamma(R2)) # "Math" group
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x0927aa60>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x0927aa60>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x0927aa60>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x0927aa60>
-
-> 
-> ## "Arith" group
-> Map(2/R1)
-[[1]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x
-    }
-    2/f2(x)
-}
-<environment: 0x0934b358>
-
-[[2]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^2
-    }
-    2/f2(x)
-}
-<environment: 0x0934b358>
-
-[[3]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^3
-    }
-    2/f2(x)
-}
-<environment: 0x0934b358>
-
-[[4]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^4
-    }
-    2/f2(x)
-}
-<environment: 0x0934b358>
-
-[[5]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^5
-    }
-    2/f2(x)
-}
-<environment: 0x0934b358>
-
-[[6]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^6
-    }
-    2/f2(x)
-}
-<environment: 0x0934b358>
-
-> Map(R2 * R2)
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    f2 <- function (x) 
-    {
-        exp(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x0950faa0>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    f2 <- function (x) 
-    {
-        abs(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x0950faa0>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    f2 <- function (x) 
-    {
-        sin(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x0950faa0>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    f2 <- function (x) 
-    {
-        floor(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x0950faa0>
-
-> 
-> 
-> 
-> cleanEx()
-> nameEx("EuclRandMatrix")
-> ### * EuclRandMatrix
-> 
-> flush(stderr()); flush(stdout())
-> 
-> ### Name: EuclRandMatrix
-> ### Title: Generating function for EuclRandMatrix-class
-> ### Aliases: EuclRandMatrix
-> ### Keywords: classes
-> 
-> ### ** Examples
-> 
-> L1 <- list(function(x){x}, function(x){x^2}, function(x){x^3}, function(x){x^4}, 
-+            function(x){x^5}, function(x){x^6})
-> L2 <- list(function(x){exp(x)}, function(x){abs(x)}, 
-+            function(x){sin(x)}, function(x){floor(x)})
-> 
-> R1 <- EuclRandMatrix(Map = L1, nrow = 3, Domain = Reals(), dimension = 1)
-> R1[1:2, 2]
-An object of class "EuclRandVariable" 
-length of Map:	 2 
-Domain:	Real Space with dimension 1 
-Range:	Euclidean Space with dimension 1 
-> R1[1:2, 1:2]
-An object of class "EuclRandMatrix" 
-Dim of Map:	 2 2 
-Domain:	Real Space with dimension 1 
-Range:	Euclidean Space with dimension 1 
-> Map(R1[1,2])
-[[1]]
-function (x) 
-{
-    x^4
-}
-
-> Map(t(R1)[2,1])
-[[1]]
-function (x) 
-{
-    f <- function (x) 
-    {
-        x^4
-    }
-    t(f(x))
-}
-<environment: 0x09590110>
-
-> 
-> R2 <- EuclRandMatrix(Map = L2, ncol = 2, Domain = Reals(), dimension = 1)
-> (DL <- imageDistr(R2, Norm()))
-An object of class "DistrList"
- [[1]] Distribution Object of Class: AbscontDistribution
- [[2]] Distribution Object of Class: AbscontDistribution
- [[3]] Distribution Object of Class: AbscontDistribution
- [[4]] Distribution Object of Class: AbscontDistribution
-Warning in (new("standardGeneric", .Data = function (object)  :
-  arithmetics on distributions are understood as operations on r.v.'s
-see 'distrARITH()'; for switching off this warning see '?distroptions'
-Warning in (new("standardGeneric", .Data = function (object)  :
-  slots d,p,q have been filled using simulations; for switching off this warning see '?distroptions'
-> plot(DL)
-> 
-> Map(gamma(R2)) # "Math" group
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x08db8650>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x08db8650>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x08db8650>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    gamma(f1(x))
-}
-<environment: 0x08db8650>
-
-> 
-> ## "Arith" group
-> Map(2/R1)
-[[1]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x
-    }
-    2/f2(x)
-}
-<environment: 0x08dedf60>
-
-[[2]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^2
-    }
-    2/f2(x)
-}
-<environment: 0x08dedf60>
-
-[[3]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^3
-    }
-    2/f2(x)
-}
-<environment: 0x08dedf60>
-
-[[4]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^4
-    }
-    2/f2(x)
-}
-<environment: 0x08dedf60>
-
-[[5]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^5
-    }
-    2/f2(x)
-}
-<environment: 0x08dedf60>
-
-[[6]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^6
-    }
-    2/f2(x)
-}
-<environment: 0x08dedf60>
-
-> Map(R2 * R2)
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    f2 <- function (x) 
-    {
-        exp(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x08e32f60>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    f2 <- function (x) 
-    {
-        abs(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x08e32f60>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    f2 <- function (x) 
-    {
-        sin(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x08e32f60>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    f2 <- function (x) 
-    {
-        floor(x)
-    }
-    f1(x) * f2(x)
-}
-<environment: 0x08e32f60>
-
-> 
-> 
-> ## The function is currently defined as
-> function(Map = list(function(x){1}), nrow = 1, ncol = 1,
-+                               Domain = NULL, dimension = 1) {
-+     if (missing(nrow)) 
-+         nrow <- ceiling(length(Map)/ncol)
-+     else if (missing(ncol)) 
-+         ncol <- ceiling(length(Map)/nrow)
-+     
-+     if(missing(Range))
-+         return(new("EuclRandMatrix", Map = Map, Domain = Domain, 
-+                    Range = EuclideanSpace(dimension = dimension),
-+                    Dim = as.integer(c(nrow, ncol))))
-+     else
-+         return(new("EuclRandMatrix", Map = Map, Domain = Domain, 
-+                    Range = Range, Dim = as.integer(c(nrow, ncol))))
-+ }
-function (Map = list(function(x) {
-    1
-}), nrow = 1, ncol = 1, Domain = NULL, dimension = 1) 
-{
-    if (missing(nrow)) 
-        nrow <- ceiling(length(Map)/ncol)
-    else if (missing(ncol)) 
-        ncol <- ceiling(length(Map)/nrow)
-    if (missing(Range)) 
-        return(new("EuclRandMatrix", Map = Map, Domain = Domain, 
-            Range = EuclideanSpace(dimension = dimension), Dim = as.integer(c(nrow, 
-                ncol))))
-    else return(new("EuclRandMatrix", Map = Map, Domain = Domain, 
-        Range = Range, Dim = as.integer(c(nrow, ncol))))
-}
-> 
-> 
-> 
-> cleanEx()
-> nameEx("EuclRandVarList-class")
-> ### * EuclRandVarList-class
-> 
-> flush(stderr()); flush(stdout())
-> 
-> ### Name: EuclRandVarList-class
-> ### Title: List of Euclidean random variables
-> ### Aliases: EuclRandVarList-class numberOfMaps
-> ###   numberOfMaps,EuclRandVarList-method dimension,EuclRandVarList-method
-> ###   evalRandVar,EuclRandVarList,numeric,missing-method
-> ###   evalRandVar,EuclRandVarList,matrix,missing-method
-> ###   evalRandVar,EuclRandVarList,numeric,Distribution-method
-> ###   evalRandVar,EuclRandVarList,matrix,Distribution-method
-> ###   imageDistr,EuclRandVarList,Distribution-method
-> ###   t,EuclRandVarList-method show,EuclRandVarList-method
-> ###   Arith,numeric,EuclRandVarList-method
-> ###   Arith,EuclRandVarList,numeric-method
-> ###   Arith,EuclRandVarList,EuclRandVarList-method
-> ###   Math,EuclRandVarList-method %m%
-> ###   %m%,EuclRandVarList,EuclRandVarList-method
-> ###   %*%,matrix,EuclRandVarList-method %*%,EuclRandVarList,matrix-method
-> ###   E,UnivariateDistribution,EuclRandVarList,missing-method
-> ###   E,AbscontDistribution,EuclRandVarList,missing-method
-> ###   E,DiscreteDistribution,EuclRandVarList,missing-method
-> ###   E,MultivariateDistribution,EuclRandVarList,missing-method
-> ###   E,DiscreteMVDistribution,EuclRandVarList,missing-method
-> ###   E,UnivariateCondDistribution,EuclRandVarList,numeric-method
-> ###   E,AbscontCondDistribution,EuclRandVarList,numeric-method
-> ###   E,DiscreteCondDistribution,EuclRandVarList,numeric-method
-> ### Keywords: classes
-> 
-> ### ** Examples
-> 
-> L1 <- list(function(x){x}, function(x){x^2}, function(x){x^3}, function(x){x^4}, 
-+            function(x){x^5}, function(x){x^6})
-> L2 <- list(function(x){exp(x)}, function(x){abs(x)}, 
-+            function(x){sin(x)}, function(x){floor(x)})
-> 
-> R1 <- new("EuclRandVariable", Map = L2, Domain = Reals(), Range = Reals())
-> R2 <- EuclRandMatrix(Map = L1, ncol = 2, Domain = Reals(), dimension = 1)
-> R3 <- EuclRandMatrix(Map = L2, ncol = 2, Domain = Reals(), dimension = 1)
-> 
-> (RL1 <- new("EuclRandVarList", list(R1, R2, R3)))
-An object of class "EuclRandVarList" 
-Domain:	Real Space with dimension 1 
-[[1]]
-length of Map:	 4 
-Range:	Real Space with dimension 1 
-[[2]]
-Dim of Map:	 3 2 
-Range:	Euclidean Space with dimension 1 
-[[3]]
-Dim of Map:	 2 2 
-Range:	Euclidean Space with dimension 1 
-> dimension(RL1)
-[1] 14
-> as(R1, "EuclRandVarList")
-An object of class "EuclRandVarList" 
-Domain:	Real Space with dimension 1 
-[[1]]
-length of Map:	 4 
-Range:	Real Space with dimension 1 
-> as(R2, "EuclRandVarList")
-An object of class "EuclRandVarList" 
-Domain:	Real Space with dimension 1 
-[[1]]
-Dim of Map:	 3 2 
-Range:	Euclidean Space with dimension 1 
-> 
-> Map(exp(RL1)[[1]]) # "Math" group
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x090f61b8>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x090f61b8>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x090f61b8>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x090f61b8>
-
-> 
-> ## "Arith" group
-> Map((1 + RL1)[[1]])
-[[1]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        exp(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x091a40b8>
-
-[[2]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        abs(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x091a40b8>
-
-[[3]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        sin(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x091a40b8>
-
-[[4]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        floor(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x091a40b8>
-
-> Map((RL1 * 2)[[2]])
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x
-    }
-    f1(x) * 2
-}
-<environment: 0x092aa678>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^2
-    }
-    f1(x) * 2
-}
-<environment: 0x092aa678>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^3
-    }
-    f1(x) * 2
-}
-<environment: 0x092aa678>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^4
-    }
-    f1(x) * 2
-}
-<environment: 0x092aa678>
-
-[[5]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^5
-    }
-    f1(x) * 2
-}
-<environment: 0x092aa678>
-
-[[6]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^6
-    }
-    f1(x) * 2
-}
-<environment: 0x092aa678>
-
-> Map((RL1 / RL1)[[3]])
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    f2 <- function (x) 
-    {
-        exp(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x095768a8>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    f2 <- function (x) 
-    {
-        abs(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x095768a8>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    f2 <- function (x) 
-    {
-        sin(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x095768a8>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    f2 <- function (x) 
-    {
-        floor(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x095768a8>
-
-> 
-> 
-> 
-> cleanEx()
-> nameEx("EuclRandVarList")
-> ### * EuclRandVarList
-> 
-> flush(stderr()); flush(stdout())
-> 
-> ### Name: EuclRandVarList
-> ### Title: Generating function for EuclRandVarList-class
-> ### Aliases: EuclRandVarList
-> ### Keywords: classes
-> 
-> ### ** Examples
-> 
-> L1 <- list(function(x){x}, function(x){x^2}, function(x){x^3}, function(x){x^4}, 
-+            function(x){x^5}, function(x){x^6})
-> L2 <- list(function(x){exp(x)}, function(x){abs(x)}, 
-+            function(x){sin(x)}, function(x){floor(x)})
-> 
-> R1 <- new("EuclRandVariable", Map = L2, Domain = Reals(), Range = Reals())
-> R2 <- EuclRandMatrix(Map = L1, ncol = 2, Domain = Reals(), dimension = 1)
-> R3 <- EuclRandMatrix(Map = L2, ncol = 2, Domain = Reals(), dimension = 1)
-> 
-> (RL1 <- EuclRandVarList(R1, R2, R3))
-An object of class "EuclRandVarList" 
-Domain:	Real Space with dimension 1 
-[[1]]
-length of Map:	 4 
-Range:	Real Space with dimension 1 
-[[2]]
-Dim of Map:	 3 2 
-Range:	Euclidean Space with dimension 1 
-[[3]]
-Dim of Map:	 2 2 
-Range:	Euclidean Space with dimension 1 
-> is(R1, "EuclRandVarList")
-[1] FALSE
-> as(R1, "EuclRandVarList")
-An object of class "EuclRandVarList" 
-Domain:	Real Space with dimension 1 
-[[1]]
-length of Map:	 4 
-Range:	Real Space with dimension 1 
-> is(R2, "EuclRandVarList")
-[1] FALSE
-> as(R2, "EuclRandVarList")
-An object of class "EuclRandVarList" 
-Domain:	Real Space with dimension 1 
-[[1]]
-Dim of Map:	 3 2 
-Range:	Euclidean Space with dimension 1 
-> 
-> Map(exp(RL1)[[1]]) # "Math" group
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x09636798>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x09636798>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x09636798>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    exp(f1(x))
-}
-<environment: 0x09636798>
-
-> 
-> ## "Arith" group
-> Map((1 + RL1)[[1]])
-[[1]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        exp(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x09687d68>
-
-[[2]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        abs(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x09687d68>
-
-[[3]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        sin(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x09687d68>
-
-[[4]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        floor(x)
-    }
-    1 + f2(x)
-}
-<environment: 0x09687d68>
-
-> Map((RL1 * 2)[[2]])
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x
-    }
-    f1(x) * 2
-}
-<environment: 0x096edb68>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^2
-    }
-    f1(x) * 2
-}
-<environment: 0x096edb68>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^3
-    }
-    f1(x) * 2
-}
-<environment: 0x096edb68>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^4
-    }
-    f1(x) * 2
-}
-<environment: 0x096edb68>
-
-[[5]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^5
-    }
-    f1(x) * 2
-}
-<environment: 0x096edb68>
-
-[[6]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^6
-    }
-    f1(x) * 2
-}
-<environment: 0x096edb68>
-
-> Map((RL1 / RL1)[[3]])
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    f2 <- function (x) 
-    {
-        exp(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x09789d60>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    f2 <- function (x) 
-    {
-        abs(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x09789d60>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    f2 <- function (x) 
-    {
-        sin(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x09789d60>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    f2 <- function (x) 
-    {
-        floor(x)
-    }
-    f1(x)/f2(x)
-}
-<environment: 0x09789d60>
-
-> 
-> ## The function is currently defined as
-> function(...){ 
-+     new("EuclRandVarList", list(...)) 
-+ }
-function (...) 
-{
-    new("EuclRandVarList", list(...))
-}
-> 
-> 
-> 
-> cleanEx()
-> nameEx("EuclRandVariable-class")
-> ### * EuclRandVariable-class
-> 
-> flush(stderr()); flush(stdout())
-> 
-> ### Name: EuclRandVariable-class
-> ### Title: Euclidean random variable
-> ### Aliases: EuclRandVariable-class
-> ###   coerce,EuclRandVariable,EuclRandMatrix-method
-> ###   coerce,EuclRandVariable,EuclRandVarList-method
-> ###   Range<-,EuclRandVariable-method [,EuclRandVariable-method evalRandVar
-> ###   evalRandVar,EuclRandVariable,numeric,missing-method
-> ###   evalRandVar,EuclRandVariable,matrix,missing-method
-> ###   evalRandVar,EuclRandVariable,numeric,Distribution-method
-> ###   evalRandVar,EuclRandVariable,matrix,Distribution-method imageDistr
-> ###   imageDistr,EuclRandVariable,Distribution-method
-> ###   dimension,EuclRandVariable-method t,EuclRandVariable-method
-> ###   %*%,matrix,EuclRandVariable-method
-> ###   %*%,numeric,EuclRandVariable-method
-> ###   %*%,EuclRandVariable,matrix-method
-> ###   %*%,EuclRandVariable,numeric-method
-> ###   %*%,EuclRandVariable,EuclRandVariable-method
-> ###   %*%,EuclRandVariable,EuclRandMatrix-method
-> ###   %*%,EuclRandMatrix,EuclRandVariable-method
-> ###   Arith,numeric,EuclRandVariable-method
-> ###   Arith,EuclRandVariable,numeric-method
-> ###   Arith,EuclRandVariable,EuclRandVariable-method
-> ###   Math,EuclRandVariable-method
-> ###   E,UnivariateDistribution,EuclRandVariable,missing-method
-> ###   E,AbscontDistribution,EuclRandVariable,missing-method
-> ###   E,DiscreteDistribution,EuclRandVariable,missing-method
-> ###   E,MultivariateDistribution,EuclRandVariable,missing-method
-> ###   E,DiscreteMVDistribution,EuclRandVariable,missing-method
-> ###   E,UnivariateCondDistribution,EuclRandVariable,numeric-method
-> ###   E,AbscontCondDistribution,EuclRandVariable,numeric-method
-> ###   E,DiscreteCondDistribution,EuclRandVariable,numeric-method
-> ### Keywords: classes arith math
-> 
-> ### ** Examples
-> 
-> L1 <- list(function(x){x}, function(x){x^2}, function(x){x^3}, function(x){x^4})
-> L2 <- list(function(x){exp(x)}, function(x){abs(x)}, 
-+            function(x){sin(x)}, function(x){floor(x)})
-> 
-> R1 <- new("EuclRandVariable", Map = L1, Domain = Reals(), Range = Reals())
-> dimension(R1)
-[1] 4
-> Map(R1)
-[[1]]
-function (x) 
-{
-    x
-}
-
-[[2]]
-function (x) 
-{
-    x^2
-}
-
-[[3]]
-function (x) 
-{
-    x^3
-}
-
-[[4]]
-function (x) 
-{
-    x^4
-}
-
-> Range(R1)
-An object of class "Reals"
-Slot "dimension":
-[1] 1
-
-Slot "name":
-[1] "Real Space"
-
-> R1[2]
-An object of class "EuclRandVariable" 
-length of Map:	 1 
-Domain:	Real Space with dimension 1 
-Range:	Real Space with dimension 1 
-> Map(R1[3])
-[[1]]
-function (x) 
-{
-    x^3
-}
-
-> Map(R1[c(1,2,4)])
-[[1]]
-function (x) 
-{
-    x
-}
-
-[[2]]
-function (x) 
-{
-    x^2
-}
-
-[[3]]
-function (x) 
-{
-    x^4
-}
-
-> Map(R1[2:4])
-[[1]]
-function (x) 
-{
-    x^2
-}
-
-[[2]]
-function (x) 
-{
-    x^3
-}
-
-[[3]]
-function (x) 
-{
-    x^4
-}
-
-> set.seed(123)
-> evalRandVar(R1, rnorm(1))
-            [,1]
-[1,] -0.56047565
-[2,]  0.31413295
-[3,] -0.17606387
-[4,]  0.09867951
-> x <- as.matrix(rnorm(10))
-> res.R1 <- evalRandVar(R1, x)
-> res.R1[2,,] # results for Map(R1)[[2]](x)
- [1] 0.052981677 2.429571609 0.004971433 0.016715318 2.941447909 0.212443749
- [7] 1.600379927 0.471766840 0.198614592 1.498376247
-> res.R1[2,1,] # results for Map(R1)[[2]](x[1,])
-[1] 0.05298168
-> 
-> R2 <- EuclRandVariable(L2, Domain = Reals(), dimension = 1)
-> dimension(R2)
-[1] 4
-> DL1 <- imageDistr(R2, Norm())
-> plot(DL1)
-> 
-> Domain(R2) <- EuclideanSpace(dimension = 2)
-> Range(R2) <- EuclideanSpace(dimension = 2)
-> dimension(R2)
-[1] 8
-> (X <- matrix(c(x, rnorm(10)), ncol = 2))
-             [,1]       [,2]
- [1,] -0.23017749  0.3598138
- [2,]  1.55870831  0.4007715
- [3,]  0.07050839  0.1106827
- [4,]  0.12928774 -0.5558411
- [5,]  1.71506499  1.7869131
- [6,]  0.46091621  0.4978505
- [7,] -1.26506123 -1.9666172
- [8,] -0.68685285  0.7013559
- [9,] -0.44566197 -0.4727914
-[10,]  1.22408180 -1.0678237
-> res.R2 <- evalRandVar(R2, X)
-> res.R2[3,,1] # results for Map(R2)[[3]](X[,1])
- [1] -0.22815034  0.99992694  0.07044998  0.12892786  0.98961131  0.44476889
- [7] -0.95362595 -0.63410681 -0.43105529  0.94049422
-> 
-> Map(log(abs(R2))) # "Math" group generic
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        f1 <- function (x) 
-        {
-            exp(x)
-        }
-        abs(f1(x))
-    }
-    log(f1(x))
-}
-<environment: 0x08487d00>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        f1 <- function (x) 
-        {
-            abs(x)
-        }
-        abs(f1(x))
-    }
-    log(f1(x))
-}
-<environment: 0x08487d00>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        f1 <- function (x) 
-        {
-            sin(x)
-        }
-        abs(f1(x))
-    }
-    log(f1(x))
-}
-<environment: 0x08487d00>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        f1 <- function (x) 
-        {
-            floor(x)
-        }
-        abs(f1(x))
-    }
-    log(f1(x))
-}
-<environment: 0x08487d00>
-
-> 
-> # "Arith" group generic
-> Map(3 + R1)
-[[1]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x
-    }
-    3 + f2(x)
-}
-<environment: 0x08496a10>
-
-[[2]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^2
-    }
-    3 + f2(x)
-}
-<environment: 0x08496a10>
-
-[[3]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^3
-    }
-    3 + f2(x)
-}
-<environment: 0x08496a10>
-
-[[4]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^4
-    }
-    3 + f2(x)
-}
-<environment: 0x08496a10>
-
-> Map(c(1,3,5) * R1)
-Warning in c(1, 3, 5) * R1 :
-  longer object length is not a multiple of shorter object length
-[[1]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x
-    }
-    1 * f2(x)
-}
-<environment: 0x084c8420>
-
-[[2]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^2
-    }
-    3 * f2(x)
-}
-<environment: 0x084c8420>
-
-[[3]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^3
-    }
-    5 * f2(x)
-}
-<environment: 0x084c8420>
-
-[[4]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        x^4
-    }
-    1 * f2(x)
-}
-<environment: 0x084c8420>
-
-> try(1:5 * R1) # error
-Error in 1:5 * R1 : 
-  length of 'numeric' has to be less or equal dimension of 'EuclRandVariable'
-> Map(1:2 * R2)
-[[1]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        exp(x)
-    }
-    1:2 * f2(x)
-}
-<environment: 0x08539980>
-
-[[2]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        abs(x)
-    }
-    1:2 * f2(x)
-}
-<environment: 0x08539980>
-
-[[3]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        sin(x)
-    }
-    1:2 * f2(x)
-}
-<environment: 0x08539980>
-
-[[4]]
-function (x) 
-{
-    f2 <- function (x) 
-    {
-        floor(x)
-    }
-    1:2 * f2(x)
-}
-<environment: 0x08539980>
-
-> Map(R2 - 5)
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        exp(x)
-    }
-    f1(x) - c(5, 5)
-}
-<environment: 0x08588520>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        abs(x)
-    }
-    f1(x) - c(5, 5)
-}
-<environment: 0x08588520>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        sin(x)
-    }
-    f1(x) - c(5, 5)
-}
-<environment: 0x08588520>
-
-[[4]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        floor(x)
-    }
-    f1(x) - c(5, 5)
-}
-<environment: 0x08588520>
-
-> Map(R1 ^ R1)
-[[1]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x
-    }
-    f2 <- function (x) 
-    {
-        x
-    }
-    f1(x)^f2(x)
-}
-<environment: 0x085caac8>
-
-[[2]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^2
-    }
-    f2 <- function (x) 
-    {
-        x^2
-    }
-    f1(x)^f2(x)
-}
-<environment: 0x085caac8>
-
-[[3]]
-function (x) 
-{
-    f1 <- function (x) 
-    {
-        x^3
-    }
-    f2 <- function (x) 
-    {
-        x^3
-    }
-    f1(x)^f2(x)
[TRUNCATED]

To get the complete diff run:
    svnlook diff /svnroot/robast -r 1262


More information about the Robast-commits mailing list