Re: [Rd] V2.9.0 changes [Sec=Unclassified]
> -Original Message-
> From: Martin Morgan [mailto:mtmor...@fhcrc.org]
> Sent: Thursday, 2 July 2009 10:58 PM
> To: Troy Robertson
> Cc: 'r-devel@R-project.org'
> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
>
> Troy Robertson wrote:
> > Well...
> >
> > My performance problems were in the pass-by-value semantics of R.
> >
> > I have just changed my classes to inherit from .environment and then
> moved data members from S4 slots to the .xData objects as Martin
> suggested.
>
> Actually, I had hoped the take-home message would be in the final
> paragraph:
>
> >> Of course I haven't seen your code, but a different interpretation of
> >> your performance issues is that, within the rules of S4, you've chosen
> >> to implement functionality in an inefficient way. So it might be
> >> instructive to step back a bit and try to reformulate your data
> >> structures and methods. This is hard to do.
>
Yes, it just takes a little time and playing around to work out the rules of R
(and S4) though, and how to use them to your advantage rather than be limited
by them. I know I am still probably not using this functional language in the
best way, but there you go.
>
> > That meant I could remove all my returns and assignments on all method
> calls.
> >
> > This has sped execution time for my model up by more than an order of
> magnitude. Eg one test simulation from 1931 secs down to 175 secs.
> >
> > Not bad seeing as though the class structure, functionality and logic
> has not been touched.
> >
> > I really do think S4 could benfit from having its slots stored in
> environment when the class enherits from .environment. It would be a lot
> more sensible if my data members were still declared as S4 slots instead
> of having to hide them in .xData
> >
> > Troy
> >
> >
> > Troy Robertson
> > Database and Computing Support Provider
> > Southern Ocean Ecosystems, ERM/Fish
> > Australian Antarctic Division
> > Channel Highway, Kingston 7050
> > PH: 03 62323571
> > troy.robert...@aad.gov.au
> >
> >
> >> -Original Message-
> >> From: Martin Morgan [mailto:mtmor...@fhcrc.org]
> >> Sent: Tuesday, 23 June 2009 11:25 PM
> >> To: Troy Robertson
> >> Cc: 'r-devel@R-project.org'
> >> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
> >>
> >> Troy Robertson wrote:
> >>> Hi all,
> >>>
> >>>
> >>>
> >>> Prefix: I am a frustrated Java coder in R.
> >> ah good, if you're frustrated with Java you'll find R very different ;)
> >>
> >>>
> >>>
> >>> I am coding a medium sized ecosystem modelling program in R. I have
> >> changed to using S4 objects and it has cost me an order of magnitude in
> >> execution speed over the functional model. I cannot afford this
> penalty
> >> and have found that it is the result of all the passing-by-value of
> >> objects.
> >>>
> >>>
> >>> I see that you can now safely inherit from environment in V2.9.0.
> >>>
> >>> That got me all excited that I would now be able to pass objects by
> >> reference.
> >>>
> >>>
> >>> But...
> >>>
> >>> That doesn't seem to be the case.
> >>>
> >>> It only seem that passing an environment which holds the object allows
> >> for pass-by-reference and that passing an object which inherits from
> >> environment doesn't.
> >>> Why is this the case, either an object inherits the properties of its
> >> parent or it doesn't.
> >>
> >> The object inherits slots from it's parent, and the methods defined on
> >> the parent class. Maybe this example helps?
> >>
> >> setClass("Ticker", contains=".environment")
> >>
> >> ## initialize essential, so each instance gets its own environment
> >> setMethod(initialize, "Ticker",
> >> function(.Object, ..., .xData=new.env(parent=emptyenv()))
> >> {
> >> .xData[["count"]] <- 0
> >> callNextMethod(.Object, ..., .xData=.xData)
> >> })
> >>
> >> ## tick: increment (private) counter by n
> >> setGeneric("tick", function(reference, n=1L) standardGeneric("tick"),
> >>signature="reference")
> >>
> >> setMethod(tick, "Ticke
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
On Thu, Jul 2, 2009 at 1:37 AM, Troy Robertson wrote:
> Well...
>
> My performance problems were in the pass-by-value semantics of R.
>
> I have just changed my classes to inherit from .environment and then moved
> data members from S4 slots to the .xData objects as Martin suggested.
>
Note that the R.oo and proto packages already use environments for
their storage. e.g.
library(proto)
p <- proto(a = 1, incr = function(.) .$a <- .$a + 1)
class(p) # c("proto", "environment")
p$a # 1
p$incr()
p$a # 2
p$ls() # c("a", "incr")
ls(p) # same
__
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
Troy Robertson wrote:
> Well...
>
> My performance problems were in the pass-by-value semantics of R.
>
> I have just changed my classes to inherit from .environment and then moved
> data members from S4 slots to the .xData objects as Martin suggested.
Actually, I had hoped the take-home message would be in the final paragraph:
>> Of course I haven't seen your code, but a different interpretation of
>> your performance issues is that, within the rules of S4, you've chosen
>> to implement functionality in an inefficient way. So it might be
>> instructive to step back a bit and try to reformulate your data
>> structures and methods. This is hard to do.
Martin
> That meant I could remove all my returns and assignments on all method calls.
>
> This has sped execution time for my model up by more than an order of
> magnitude. Eg one test simulation from 1931 secs down to 175 secs.
>
> Not bad seeing as though the class structure, functionality and logic has not
> been touched.
>
> I really do think S4 could benfit from having its slots stored in environment
> when the class enherits from .environment. It would be a lot more sensible
> if my data members were still declared as S4 slots instead of having to hide
> them in .xData
>
> Troy
>
>
> Troy Robertson
> Database and Computing Support Provider
> Southern Ocean Ecosystems, ERM/Fish
> Australian Antarctic Division
> Channel Highway, Kingston 7050
> PH: 03 62323571
> troy.robert...@aad.gov.au
>
>
>> -Original Message-
>> From: Martin Morgan [mailto:mtmor...@fhcrc.org]
>> Sent: Tuesday, 23 June 2009 11:25 PM
>> To: Troy Robertson
>> Cc: 'r-devel@R-project.org'
>> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
>>
>> Troy Robertson wrote:
>>> Hi all,
>>>
>>>
>>>
>>> Prefix: I am a frustrated Java coder in R.
>> ah good, if you're frustrated with Java you'll find R very different ;)
>>
>>>
>>>
>>> I am coding a medium sized ecosystem modelling program in R. I have
>> changed to using S4 objects and it has cost me an order of magnitude in
>> execution speed over the functional model. I cannot afford this penalty
>> and have found that it is the result of all the passing-by-value of
>> objects.
>>>
>>>
>>> I see that you can now safely inherit from environment in V2.9.0.
>>>
>>> That got me all excited that I would now be able to pass objects by
>> reference.
>>>
>>>
>>> But...
>>>
>>> That doesn't seem to be the case.
>>>
>>> It only seem that passing an environment which holds the object allows
>> for pass-by-reference and that passing an object which inherits from
>> environment doesn't.
>>> Why is this the case, either an object inherits the properties of its
>> parent or it doesn't.
>>
>> The object inherits slots from it's parent, and the methods defined on
>> the parent class. Maybe this example helps?
>>
>> setClass("Ticker", contains=".environment")
>>
>> ## initialize essential, so each instance gets its own environment
>> setMethod(initialize, "Ticker",
>> function(.Object, ..., .xData=new.env(parent=emptyenv()))
>> {
>> .xData[["count"]] <- 0
>> callNextMethod(.Object, ..., .xData=.xData)
>> })
>>
>> ## tick: increment (private) counter by n
>> setGeneric("tick", function(reference, n=1L) standardGeneric("tick"),
>>signature="reference")
>>
>> setMethod(tick, "Ticker", function(reference, n=1L) {
>> reference[["count"]] <- reference[["count"]] + n
>> })
>>
>> ## tock: report current value of counter
>> setGeneric("tock", function(reference) standardGeneric("tock"))
>>
>> setMethod(tock, "Ticker", function(reference) {
>> reference[["count"]]
>> })
>>
>> and then
>>
>>> e <- new("Ticker")
>>> tock(e)
>> [1] 0
>>> tick(e); tick(e, 10); tock(e)
>> [1] 11
>>> f <- e
>>> tock(f); tick(e); tock(f)
>> [1] 11
>> [1] 12
>>
>> The data inside .environment could be structured, too, using S4.
>> Probably it would be more appropriate to have the environment as a slot,
>> rather the class that is being extended. And in terms of inherited
>> 'properties', e.g., the &
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
Well...
My performance problems were in the pass-by-value semantics of R.
I have just changed my classes to inherit from .environment and then moved data
members from S4 slots to the .xData objects as Martin suggested.
That meant I could remove all my returns and assignments on all method calls.
This has sped execution time for my model up by more than an order of
magnitude. Eg one test simulation from 1931 secs down to 175 secs.
Not bad seeing as though the class structure, functionality and logic has not
been touched.
I really do think S4 could benfit from having its slots stored in environment
when the class enherits from .environment. It would be a lot more sensible if
my data members were still declared as S4 slots instead of having to hide them
in .xData
Troy
Troy Robertson
Database and Computing Support Provider
Southern Ocean Ecosystems, ERM/Fish
Australian Antarctic Division
Channel Highway, Kingston 7050
PH: 03 62323571
troy.robert...@aad.gov.au
> -Original Message-
> From: Martin Morgan [mailto:mtmor...@fhcrc.org]
> Sent: Tuesday, 23 June 2009 11:25 PM
> To: Troy Robertson
> Cc: 'r-devel@R-project.org'
> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
>
> Troy Robertson wrote:
> > Hi all,
> >
> >
> >
> > Prefix: I am a frustrated Java coder in R.
>
> ah good, if you're frustrated with Java you'll find R very different ;)
>
> >
> >
> >
> > I am coding a medium sized ecosystem modelling program in R. I have
> changed to using S4 objects and it has cost me an order of magnitude in
> execution speed over the functional model. I cannot afford this penalty
> and have found that it is the result of all the passing-by-value of
> objects.
> >
> >
> >
> > I see that you can now safely inherit from environment in V2.9.0.
> >
> > That got me all excited that I would now be able to pass objects by
> reference.
> >
> >
> >
> > But...
> >
> > That doesn't seem to be the case.
> >
> > It only seem that passing an environment which holds the object allows
> for pass-by-reference and that passing an object which inherits from
> environment doesn't.
> >
> > Why is this the case, either an object inherits the properties of its
> parent or it doesn't.
>
> The object inherits slots from it's parent, and the methods defined on
> the parent class. Maybe this example helps?
>
> setClass("Ticker", contains=".environment")
>
> ## initialize essential, so each instance gets its own environment
> setMethod(initialize, "Ticker",
> function(.Object, ..., .xData=new.env(parent=emptyenv()))
> {
> .xData[["count"]] <- 0
> callNextMethod(.Object, ..., .xData=.xData)
> })
>
> ## tick: increment (private) counter by n
> setGeneric("tick", function(reference, n=1L) standardGeneric("tick"),
>signature="reference")
>
> setMethod(tick, "Ticker", function(reference, n=1L) {
> reference[["count"]] <- reference[["count"]] + n
> })
>
> ## tock: report current value of counter
> setGeneric("tock", function(reference) standardGeneric("tock"))
>
> setMethod(tock, "Ticker", function(reference) {
> reference[["count"]]
> })
>
> and then
>
> > e <- new("Ticker")
> > tock(e)
> [1] 0
> > tick(e); tick(e, 10); tock(e)
> [1] 11
> > f <- e
> > tock(f); tick(e); tock(f)
> [1] 11
> [1] 12
>
> The data inside .environment could be structured, too, using S4.
> Probably it would be more appropriate to have the environment as a slot,
> rather the class that is being extended. And in terms of inherited
> 'properties', e.g., the "[[" function as defined on environments is
> available
>
> > e[["count"]]
>
> Of course I haven't seen your code, but a different interpretation of
> your performance issues is that, within the rules of S4, you've chosen
> to implement functionality in an inefficient way. So it might be
> instructive to step back a bit and try to reformulate your data
> structures and methods. This is hard to do.
>
> Martin
>
> >
> > Has anyone else had a play with this? Or have I got it all wrong.
> >
> >
> >
> > I tried the below:
> >
> >
> -
> >
> > setClass('foo', representation=representation(stuff='list',
> bar='numeric'),
> >
> >
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
On Wed, Jun 24, 2009 at 4:27 AM, Martin
Maechler wrote:
>>>>>> "TR" == Troy Robertson
>>>>>> on Wed, 24 Jun 2009 16:35:29 +1000 writes:
>
> TR> Yes, I had looked at R.oo, S4 and proto before beginning coding. I had
> initially assumed that S4 was an enhancement of or replacement to R.oo that
> was implemented at a lower level and had decided to go with the 'future' of
> OO in R.
> TR> These assumptions were not necessarily correct.
>
> >From the view of the R core team,
> S4 *is* ``the future of OO in R''
...and until we're there, R.oo (S3) will do it for you.
/Henrik
>
> But then, as professional statisticians, we should consider the
> famous
> >>> Prediction is very difficult, especially about the future <<
> attributed to Physics Nobel Prize winner Niels Bohr.
>
> ---
>
> Martin Maechler, ETH Zurich & R-core
>
>
> TR> Troy
>
> TR> Troy Robertson
> TR> Database and Computing Support Provider
> TR> Southern Ocean Ecosystems, ERM/Fish
> TR> Australian Antarctic Division
> TR> Channel Highway, Kingston 7050
> TR> PH: 03 62323571
> TR> troy.robert...@aad.gov.au
>
>
> >> -----Original Message-----
> >> From: Antonio, Fabio Di Narzo [mailto:antonio.fa...@gmail.com]
> >> Sent: Tuesday, 23 June 2009 6:22 PM
> >> To: Troy Robertson
> >> Cc: r-devel@R-project.org
> >> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
> >>
> >> Not a direct answer to your question, but...
> >> You might consider using the R.oo package, from H. Bengtsson. It's
> >> very stable, written in pure R, and cleanly allows you to do
> >> pass-by-reference OO programming, with no tricks.
> >>
> >> HTH,
> >> af
> >>
> >> 2009/6/23 Troy Robertson :
> >> > Hi all,
> >> >
> >> >
> >> >
> >> > Prefix: I am a frustrated Java coder in R.
> >> >
> >> >
> >> >
> >> > I am coding a medium sized ecosystem modelling program in R. I have
> >> changed to using S4 objects and it has cost me an order of magnitude in
> >> execution speed over the functional model. I cannot afford this penalty
> >> and have found that it is the result of all the passing-by-value of
> >> objects.
> >> >
> >> >
> >> >
> >> > I see that you can now safely inherit from environment in V2.9.0.
> >> >
> >> > That got me all excited that I would now be able to pass objects by
> >> reference.
> >> >
> >> >
> >> >
> >> > But...
> >> >
> >> > That doesn't seem to be the case.
> >> >
> >> > It only seem that passing an environment which holds the object allows
> >> for pass-by-reference and that passing an object which inherits from
> >> environment doesn't.
> >> >
> >> > Why is this the case, either an object inherits the properties of its
> >> parent or it doesn't.
> >> >
> >> > Has anyone else had a play with this? Or have I got it all wrong.
> >> >
> >> >
> >> >
> >> > I tried the below:
> >> >
> >> >
>
> >> -
> >> >
> >> > setClass('foo', representation=representation(stuff='list',
> >> bar='numeric'),
> >> >
> >> > prototype=list(stuff=list(), bar=0),
> >> >
> >> > contains='.environment')
> >> >
> >> >
> >> >
> >> > setGeneric('doit', function(.Object, newfoo='environment')
> >> standardGeneric('doit'))
> >> >
> >> >
> >> >
> >> > setMethod('doit', 'foo', function(.Object, newfoo){new...@bar <- 10})
> >> >
> >> >
> >> >
> >> > z <- new('foo')
> >> >
> >> >
> >> >
> >> > z...@stuff$x <- new('foo')
> >> >
> >> >
> >> >
> >> > doit(z,z...@stuff$x)
> >> >
> >> >
> >> >
> >> > z...@stuff$x@bar
> >> >
> >> >
> >> >
> >> > [1] 0
> >> >
> >> >
>
> >> --
> >> >
> >> >
> >> >
> >> > Can anyone help with a better way of doing this.
> >> >
> >> > I'm trying to avoid all the indirection of packing and unpacking
> >> environments for passing.
> >> >
> >> >
> >> >
> >> >
> >> >
> >> > Thanks heaps
> >> >
> >> > Troy
> >> >
>
> ..
>
>
> >> --
> >> Antonio, Fabio Di Narzo
> >> Ph.D. student at
> >> Department of Statistical Sciences
> >> University of Bologna, Italy
> TR>
> ___
>
> __
> R-devel@r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>
__
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
Martin Maechler wrote: > > But then, as professional statisticians, we should consider the > famous >>>> Prediction is very difficult, especially about the future << > attributed to Physics Nobel Prize winner Niels Bohr. ...and quotations are even more difficult! A number of people are known NOT to be the source of that one, including Bohr, Robert Storm Petersen, and former minister of culture Steincke (in his memoirs, he mentions it being used in parliament some time during 1935--1939, but he forgot by whom). One source has "Markus M. Ronner, and others" (he was born in 1938, though!) -- O__ Peter Dalgaard Øster Farimagsgade 5, Entr.B c/ /'_ --- Dept. of Biostatistics PO Box 2099, 1014 Cph. K (*) \(*) -- University of Copenhagen Denmark Ph: (+45) 35327918 ~~ - (p.dalga...@biostat.ku.dk) FAX: (+45) 35327907 __ R-devel@r-project.org mailing list https://stat.ethz.ch/mailman/listinfo/r-devel
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
>>>>> "TR" == Troy Robertson
>>>>> on Wed, 24 Jun 2009 16:35:29 +1000 writes:
TR> Yes, I had looked at R.oo, S4 and proto before beginning coding. I had
initially assumed that S4 was an enhancement of or replacement to R.oo that was
implemented at a lower level and had decided to go with the 'future' of OO in R.
TR> These assumptions were not necessarily correct.
>From the view of the R core team,
S4 *is* ``the future of OO in R''
But then, as professional statisticians, we should consider the
famous
>>> Prediction is very difficult, especially about the future <<
attributed to Physics Nobel Prize winner Niels Bohr.
---
Martin Maechler, ETH Zurich & R-core
TR> Troy
TR> Troy Robertson
TR> Database and Computing Support Provider
TR> Southern Ocean Ecosystems, ERM/Fish
TR> Australian Antarctic Division
TR> Channel Highway, Kingston 7050
TR> PH: 03 62323571
TR> troy.robert...@aad.gov.au
>> -Original Message-
>> From: Antonio, Fabio Di Narzo [mailto:antonio.fa...@gmail.com]
>> Sent: Tuesday, 23 June 2009 6:22 PM
>> To: Troy Robertson
>> Cc: r-devel@R-project.org
>> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
>>
>> Not a direct answer to your question, but...
>> You might consider using the R.oo package, from H. Bengtsson. It's
>> very stable, written in pure R, and cleanly allows you to do
>> pass-by-reference OO programming, with no tricks.
>>
>> HTH,
>> af
>>
>> 2009/6/23 Troy Robertson :
>> > Hi all,
>> >
>> >
>> >
>> > Prefix: I am a frustrated Java coder in R.
>> >
>> >
>> >
>> > I am coding a medium sized ecosystem modelling program in R. I have
>> changed to using S4 objects and it has cost me an order of magnitude in
>> execution speed over the functional model. I cannot afford this penalty
>> and have found that it is the result of all the passing-by-value of
>> objects.
>> >
>> >
>> >
>> > I see that you can now safely inherit from environment in V2.9.0.
>> >
>> > That got me all excited that I would now be able to pass objects by
>> reference.
>> >
>> >
>> >
>> > But...
>> >
>> > That doesn't seem to be the case.
>> >
>> > It only seem that passing an environment which holds the object allows
>> for pass-by-reference and that passing an object which inherits from
>> environment doesn't.
>> >
>> > Why is this the case, either an object inherits the properties of its
>> parent or it doesn't.
>> >
>> > Has anyone else had a play with this? Or have I got it all wrong.
>> >
>> >
>> >
>> > I tried the below:
>> >
>> >
>> -
>> >
>> > setClass('foo', representation=representation(stuff='list',
>> bar='numeric'),
>> >
>> > prototype=list(stuff=list(), bar=0),
>> >
>> > contains='.environment')
>> >
>> >
>> >
>> > setGeneric('doit', function(.Object, newfoo='environment')
>> standardGeneric('doit'))
>> >
>> >
>> >
>> > setMethod('doit', 'foo', function(.Object, newfoo){new...@bar <- 10})
>> >
>> >
>> >
>> > z <- new('foo')
>> >
>> >
>> >
>> > z...@stuff$x <- new('foo')
>> >
>> >
>> >
>> > doit(z,z...@stuff$x)
>> >
>> >
>> >
>> > z...@stuff$x@bar
>> >
>> >
>> >
>> > [1] 0
>> >
>> >
>> --
>> >
>> >
>> >
>> > Can anyone help with a better way of doing this.
>> >
>> > I'm trying to avoid all the indirection of packing and unpacking
>> environments for passing.
>> >
>> >
>> >
>> >
>> >
>> > Thanks heaps
>> >
>> > Troy
>> >
..
>> --
>> Antonio, Fabio Di Narzo
>> Ph.D. student at
>> Department of Statistical Sciences
>> University of Bologna, Italy
TR>
___
__
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
Thanks Martin,
Yes I can see that a slot can be initialised as an environment, and data stored
within that environment but it seems to then require an additional layer of
indirection to access data members within the environment and negates the use
of slots in the first place.
The same goes for the "[[" function which works on an object which extends
environment as I would expect slots within that object to work (but don't), eg
allowing a pass-by-reference arrangement.
I hadn't encountered the use of .xdata as you demonstrated below and think I
can work with this way of assigning data members to an S4 object, allowing for
a pass-by-reference mechanism. It just seems to negate the point of providing
a slot mechanism for objects.
As for stepping back and re-thinking the way I am implementing my data
structures and methods. It is difficult coming from one way of coding in a
different language. It's easy to try and enforce that way of doing things on
the new language. Can you point me to any examples of general programming
using S4 that I could use to change my way of thinking about the problem?
I will have a play around more tomorrow.
Cheers
Troy
> -Original Message-
> From: Martin Morgan [mailto:mtmor...@fhcrc.org]
> Sent: Tuesday, 23 June 2009 11:25 PM
> To: Troy Robertson
> Cc: 'r-devel@R-project.org'
> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
>
> Troy Robertson wrote:
> > Hi all,
> >
> >
> >
> > Prefix: I am a frustrated Java coder in R.
>
> ah good, if you're frustrated with Java you'll find R very different ;)
>
> >
> >
> >
> > I am coding a medium sized ecosystem modelling program in R. I have
> changed to using S4 objects and it has cost me an order of magnitude in
> execution speed over the functional model. I cannot afford this penalty
> and have found that it is the result of all the passing-by-value of
> objects.
> >
> >
> >
> > I see that you can now safely inherit from environment in V2.9.0.
> >
> > That got me all excited that I would now be able to pass objects by
> reference.
> >
> >
> >
> > But...
> >
> > That doesn't seem to be the case.
> >
> > It only seem that passing an environment which holds the object allows
> for pass-by-reference and that passing an object which inherits from
> environment doesn't.
> >
> > Why is this the case, either an object inherits the properties of its
> parent or it doesn't.
>
> The object inherits slots from it's parent, and the methods defined on
> the parent class. Maybe this example helps?
>
> setClass("Ticker", contains=".environment")
>
> ## initialize essential, so each instance gets its own environment
> setMethod(initialize, "Ticker",
> function(.Object, ..., .xData=new.env(parent=emptyenv()))
> {
> .xData[["count"]] <- 0
> callNextMethod(.Object, ..., .xData=.xData)
> })
>
> ## tick: increment (private) counter by n
> setGeneric("tick", function(reference, n=1L) standardGeneric("tick"),
>signature="reference")
>
> setMethod(tick, "Ticker", function(reference, n=1L) {
> reference[["count"]] <- reference[["count"]] + n
> })
>
> ## tock: report current value of counter
> setGeneric("tock", function(reference) standardGeneric("tock"))
>
> setMethod(tock, "Ticker", function(reference) {
> reference[["count"]]
> })
>
> and then
>
> > e <- new("Ticker")
> > tock(e)
> [1] 0
> > tick(e); tick(e, 10); tock(e)
> [1] 11
> > f <- e
> > tock(f); tick(e); tock(f)
> [1] 11
> [1] 12
>
> The data inside .environment could be structured, too, using S4.
> Probably it would be more appropriate to have the environment as a slot,
> rather the class that is being extended. And in terms of inherited
> 'properties', e.g., the "[[" function as defined on environments is
> available
>
> > e[["count"]]
>
> Of course I haven't seen your code, but a different interpretation of
> your performance issues is that, within the rules of S4, you've chosen
> to implement functionality in an inefficient way. So it might be
> instructive to step back a bit and try to reformulate your data
> structures and methods. This is hard to do.
>
> Martin
>
> >
> > Has anyone else had a play with this? Or have I got it all wrong.
> >
> >
&
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
Yes, I had looked at R.oo, S4 and proto before beginning coding. I had
initially assumed that S4 was an enhancement of or replacement to R.oo that was
implemented at a lower level and had decided to go with the 'future' of OO in R.
These assumptions were not necessarily correct.
Troy
Troy Robertson
Database and Computing Support Provider
Southern Ocean Ecosystems, ERM/Fish
Australian Antarctic Division
Channel Highway, Kingston 7050
PH: 03 62323571
troy.robert...@aad.gov.au
> -Original Message-
> From: Antonio, Fabio Di Narzo [mailto:antonio.fa...@gmail.com]
> Sent: Tuesday, 23 June 2009 6:22 PM
> To: Troy Robertson
> Cc: r-devel@R-project.org
> Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]
>
> Not a direct answer to your question, but...
> You might consider using the R.oo package, from H. Bengtsson. It's
> very stable, written in pure R, and cleanly allows you to do
> pass-by-reference OO programming, with no tricks.
>
> HTH,
> af
>
> 2009/6/23 Troy Robertson :
> > Hi all,
> >
> >
> >
> > Prefix: I am a frustrated Java coder in R.
> >
> >
> >
> > I am coding a medium sized ecosystem modelling program in R. I have
> changed to using S4 objects and it has cost me an order of magnitude in
> execution speed over the functional model. I cannot afford this penalty
> and have found that it is the result of all the passing-by-value of
> objects.
> >
> >
> >
> > I see that you can now safely inherit from environment in V2.9.0.
> >
> > That got me all excited that I would now be able to pass objects by
> reference.
> >
> >
> >
> > But...
> >
> > That doesn't seem to be the case.
> >
> > It only seem that passing an environment which holds the object allows
> for pass-by-reference and that passing an object which inherits from
> environment doesn't.
> >
> > Why is this the case, either an object inherits the properties of its
> parent or it doesn't.
> >
> > Has anyone else had a play with this? Or have I got it all wrong.
> >
> >
> >
> > I tried the below:
> >
> >
> -
> >
> > setClass('foo', representation=representation(stuff='list',
> bar='numeric'),
> >
> > prototype=list(stuff=list(), bar=0),
> >
> > contains='.environment')
> >
> >
> >
> > setGeneric('doit', function(.Object, newfoo='environment')
> standardGeneric('doit'))
> >
> >
> >
> > setMethod('doit', 'foo', function(.Object, newfoo){new...@bar <- 10})
> >
> >
> >
> > z <- new('foo')
> >
> >
> >
> > z...@stuff$x <- new('foo')
> >
> >
> >
> > doit(z,z...@stuff$x)
> >
> >
> >
> > z...@stuff$x@bar
> >
> >
> >
> > [1] 0
> >
> >
> --
> >
> >
> >
> > Can anyone help with a better way of doing this.
> >
> > I'm trying to avoid all the indirection of packing and unpacking
> environments for passing.
> >
> >
> >
> >
> >
> > Thanks heaps
> >
> >
> >
> > Troy
> >
> >
> >
> >
> >
> > Troy Robertson
> >
> > Database and Computing Support Provider
> >
> > Southern Ocean Ecosystems, ERM/Fish
> >
> > Australian Antarctic Division
> >
> > Channel Highway, Kingston 7050
> >
> > PH: 03 62323571
> >
> > troy.robert...@aad.gov.au
> >
> >
> >
> >
> >
> __
> _
> >
> >Australian Antarctic Division - Commonwealth of Australia
> > IMPORTANT: This transmission is intended for the addressee only. If you
> are not the
> > intended recipient, you are notified that use or dissemination of this
> communication is
> > strictly prohibited by Commonwealth law. If you have received this
> transmission in error,
> > please notify the sender immediately by e-mail or by telephoning +61 3
> 6232 3209 and
> > DELETE the message.
> >Visit our web site at http://www.antarctica.gov.au/
> >
> __
> _
> >
> >[[alternative HTML version delete
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
Troy Robertson wrote:
> Hi all,
>
>
>
> Prefix: I am a frustrated Java coder in R.
ah good, if you're frustrated with Java you'll find R very different ;)
>
>
>
> I am coding a medium sized ecosystem modelling program in R. I have changed
> to using S4 objects and it has cost me an order of magnitude in execution
> speed over the functional model. I cannot afford this penalty and have found
> that it is the result of all the passing-by-value of objects.
>
>
>
> I see that you can now safely inherit from environment in V2.9.0.
>
> That got me all excited that I would now be able to pass objects by reference.
>
>
>
> But...
>
> That doesn't seem to be the case.
>
> It only seem that passing an environment which holds the object allows for
> pass-by-reference and that passing an object which inherits from environment
> doesn't.
>
> Why is this the case, either an object inherits the properties of its parent
> or it doesn't.
The object inherits slots from it's parent, and the methods defined on
the parent class. Maybe this example helps?
setClass("Ticker", contains=".environment")
## initialize essential, so each instance gets its own environment
setMethod(initialize, "Ticker",
function(.Object, ..., .xData=new.env(parent=emptyenv()))
{
.xData[["count"]] <- 0
callNextMethod(.Object, ..., .xData=.xData)
})
## tick: increment (private) counter by n
setGeneric("tick", function(reference, n=1L) standardGeneric("tick"),
signature="reference")
setMethod(tick, "Ticker", function(reference, n=1L) {
reference[["count"]] <- reference[["count"]] + n
})
## tock: report current value of counter
setGeneric("tock", function(reference) standardGeneric("tock"))
setMethod(tock, "Ticker", function(reference) {
reference[["count"]]
})
and then
> e <- new("Ticker")
> tock(e)
[1] 0
> tick(e); tick(e, 10); tock(e)
[1] 11
> f <- e
> tock(f); tick(e); tock(f)
[1] 11
[1] 12
The data inside .environment could be structured, too, using S4.
Probably it would be more appropriate to have the environment as a slot,
rather the class that is being extended. And in terms of inherited
'properties', e.g., the "[[" function as defined on environments is
available
> e[["count"]]
Of course I haven't seen your code, but a different interpretation of
your performance issues is that, within the rules of S4, you've chosen
to implement functionality in an inefficient way. So it might be
instructive to step back a bit and try to reformulate your data
structures and methods. This is hard to do.
Martin
>
> Has anyone else had a play with this? Or have I got it all wrong.
>
>
>
> I tried the below:
>
> -
>
> setClass('foo', representation=representation(stuff='list', bar='numeric'),
>
> prototype=list(stuff=list(), bar=0),
>
> contains='.environment')
>
>
>
> setGeneric('doit', function(.Object, newfoo='environment')
> standardGeneric('doit'))
>
>
>
> setMethod('doit', 'foo', function(.Object, newfoo){new...@bar <- 10})
>
>
>
> z <- new('foo')
>
>
>
> z...@stuff$x <- new('foo')
>
>
>
> doit(z,z...@stuff$x)
>
>
>
> z...@stuff$x@bar
>
>
>
> [1] 0
>
> --
>
>
>
> Can anyone help with a better way of doing this.
>
> I'm trying to avoid all the indirection of packing and unpacking environments
> for passing.
>
>
>
>
>
> Thanks heaps
>
>
>
> Troy
>
>
>
>
>
> Troy Robertson
>
> Database and Computing Support Provider
>
> Southern Ocean Ecosystems, ERM/Fish
>
> Australian Antarctic Division
>
> Channel Highway, Kingston 7050
>
> PH: 03 62323571
>
> troy.robert...@aad.gov.au
>
>
>
>
> ___
>
> Australian Antarctic Division - Commonwealth of Australia
> IMPORTANT: This transmission is intended for the addressee only. If you are
> not the
> intended recipient, you are notified that use or dissemination of this
> communication is
> strictly prohibited by Commonwealth law. If you have received this
> transmission in error,
> please notify the sender immediately by e-mail or by telephoning +61 3 6232
> 3209 and
> DELETE the message.
> Visit our web site at http://www.antarctica.gov.au/
> ___
>
> [[alternative HTML version deleted]]
>
> __
> R-devel@r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
__
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
Re: [Rd] V2.9.0 changes [Sec=Unclassified]
Not a direct answer to your question, but...
You might consider using the R.oo package, from H. Bengtsson. It's
very stable, written in pure R, and cleanly allows you to do
pass-by-reference OO programming, with no tricks.
HTH,
af
2009/6/23 Troy Robertson :
> Hi all,
>
>
>
> Prefix: I am a frustrated Java coder in R.
>
>
>
> I am coding a medium sized ecosystem modelling program in R. I have changed
> to using S4 objects and it has cost me an order of magnitude in execution
> speed over the functional model. I cannot afford this penalty and have found
> that it is the result of all the passing-by-value of objects.
>
>
>
> I see that you can now safely inherit from environment in V2.9.0.
>
> That got me all excited that I would now be able to pass objects by reference.
>
>
>
> But...
>
> That doesn't seem to be the case.
>
> It only seem that passing an environment which holds the object allows for
> pass-by-reference and that passing an object which inherits from environment
> doesn't.
>
> Why is this the case, either an object inherits the properties of its parent
> or it doesn't.
>
> Has anyone else had a play with this? Or have I got it all wrong.
>
>
>
> I tried the below:
>
> -
>
> setClass('foo', representation=representation(stuff='list', bar='numeric'),
>
> prototype=list(stuff=list(), bar=0),
>
> contains='.environment')
>
>
>
> setGeneric('doit', function(.Object, newfoo='environment')
> standardGeneric('doit'))
>
>
>
> setMethod('doit', 'foo', function(.Object, newfoo){new...@bar <- 10})
>
>
>
> z <- new('foo')
>
>
>
> z...@stuff$x <- new('foo')
>
>
>
> doit(z,z...@stuff$x)
>
>
>
> z...@stuff$x@bar
>
>
>
> [1] 0
>
> --
>
>
>
> Can anyone help with a better way of doing this.
>
> I'm trying to avoid all the indirection of packing and unpacking environments
> for passing.
>
>
>
>
>
> Thanks heaps
>
>
>
> Troy
>
>
>
>
>
> Troy Robertson
>
> Database and Computing Support Provider
>
> Southern Ocean Ecosystems, ERM/Fish
>
> Australian Antarctic Division
>
> Channel Highway, Kingston 7050
>
> PH: 03 62323571
>
> troy.robert...@aad.gov.au
>
>
>
>
> ___
>
> Australian Antarctic Division - Commonwealth of Australia
> IMPORTANT: This transmission is intended for the addressee only. If you are
> not the
> intended recipient, you are notified that use or dissemination of this
> communication is
> strictly prohibited by Commonwealth law. If you have received this
> transmission in error,
> please notify the sender immediately by e-mail or by telephoning +61 3 6232
> 3209 and
> DELETE the message.
> Visit our web site at http://www.antarctica.gov.au/
> ___
>
> [[alternative HTML version deleted]]
>
> __
> R-devel@r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>
--
Antonio, Fabio Di Narzo
Ph.D. student at
Department of Statistical Sciences
University of Bologna, Italy
__
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
