Skip to content

date operations

8 messages · Christophe Dutang, jim holtman, Gabor Grothendieck +1 more

jim holtman
# 
'str' is your friend.  Look at the results:
Time difference of 56 days
[1] "2008-12-21"
Time difference of 14290 days
Warning message:
Incompatible methods ("Ops.difftime", "+.Date") for "+"
Class 'difftime'  atomic [1:1] 56
  ..- attr(*, "units")= chr "days"
Class 'Date'  num 14234
alpha1 is not of the Date class.
On Tue, Dec 2, 2008 at 4:10 PM, Christophe Dutang <dutangc at gmail.com> wrote:

  
    

      
      
    

  


  


      

    

    

      
      

        


  

        

      jim holtman
    

    

      
      #
    

  


  

      
If you want to do the addition, 'unclass' the variable:

            

      
      
      
    

        
[1] "2008-12-25"

            

      
      
      
    

        
[1] "2009-02-15"

            

      
      
      
    

        

        
On Tue, Dec 2, 2008 at 4:10 PM, Christophe Dutang <dutangc at gmail.com> wrote:

            

      
      
      
    

        

      
      
    

        

  
    

      
      
    

  


  


      

    

    

      
      

        


  

        

      Christophe Dutang
    

    

      
      #
    

  


  

      
Thanks a lot

Envoy? de mon iPhone

Le 3 d?c. 08 ? 00:39, "jim holtman" <jholtman at gmail.com> a ?crit :

            

      
      
      
    

        

      
      
    

            

      
      
      
    

  
  


  


      

    

    

      
      

        


  

        

      Gabor Grothendieck
    

    

      
      #
    

  


  

      
What is odd is that it seems to run ok if we call "+.Date" directly:

            

      
      
      
    

        
[1] "2009-02-15"

        
On Tue, Dec 2, 2008 at 4:10 PM, Christophe Dutang <dutangc at gmail.com> wrote:

            

      
      
      
    

        

      
      
    

  
  


  


      

    

    

      
      

        


  

        

      Gavin Simpson
    

    

      
      #
    

  


  

      
On Wed, 2008-12-03 at 13:18 -0500, Gabor Grothendieck wrote:

            

      
      
      
    

        
It also works if you flip the ordering:

            

      
      
      
    

        
[1] "2009-02-15"
Warning message:
Incompatible methods ("+.Date", "Ops.difftime") for "+"

It is just a warning, but one should check that the answer is correct
given the perceived problem with different classes of objects. 

Why it works is not odd if you look at the help for ?`+.Date`, which
shows that for this method (correct term?) we need 'date' + 'x', where
'date' is an object of class Date and 'x' is numeric.

The OP can avoid the warning by:

            

      
      
      
    

        
[1] "2009-02-15"

If you put alpha1 first (class difftime) that method gets used and
alpha2 is coerced to numeric to complete the operation:

            

      
      
      
    

        
Time difference of 14290 days
Warning message:
Incompatible methods ("Ops.difftime", "+.Date") for "+"

            

      
      
      
    

        
[1] 14290

To answer the OP's question about conversion, no you don't need to
convert Date objects to numerics to work with them. You just need to be
aware of method dispatch for `+()` and check that adding objects of
differing classes makes sense.

Of course, this assumes that the OP wanted the answer as an object of
class "Date"...?

G

            

      
      
      
    

        

      
      
    

            

      
      
      
    

        

      
      
    

  
    

      
      
    

  


  


      

    

    

      
      

        


  

        

      Gabor Grothendieck
    

    

      
      #
    

  


  

      
On Wed, Dec 3, 2008 at 1:57 PM, Gavin Simpson <gavin.simpson at ucl.ac.uk> wrote:

            

      
      
      
    

        
In fact what it says is that x may be numeric OR difftime.  Also the
above does not explain it in any case because:

            

      
      
      
    

        
[1] "2009-02-15"

            

      
      
      
    

        
Time difference of 14290 days
Warning message:
Incompatible methods ("Ops.difftime", "+.Date") for "+"

            

      
      
      
    

        
His question was how to avoid using as.numeric.

            

      
      
      
    

        

      
      
    

            

      
      
      
    

        

      
      
    

            

      
      
      
    

  
  


  


      

    

    

      
      

        


  

        

      Gavin Simpson
    

    

      
      #
    

  


  

      
On Wed, 2008-12-03 at 14:13 -0500, Gabor Grothendieck wrote:

        
<snip />

            

      
      
      
    

        
Yes, sorry, got distracted with dinner...

            

      
      
      
    

        
I guess something like this is happening:

            

      
      
      
    

        
[1] "2009-02-15"

Although internally, `+.Date` deals with objects of class "difftime" for
either date or x. So technically the help for ?`+.Date` is at odds with
the code; although there is a degree of ambiguity in what a 'date
object' is?

            

      
      
      
    

        
But you are doing method dispatch yourself (by hand) in the first case
and allowing `+` to deal with it in the latter. The warning is not
coming from `+.Date`().

This looks like an infelicity in non-standard method dispatch that takes
place within `+`, a primitive function. It would be nice if `+` didn't
raise warnings about potential incompatible classes, but it can't know
in advance what methods users might write for it.

            

      
      
      
    

        
Well, I read it as not converting his "Date"s to numerics (I converted a
"difftime"). But that is splitting hairs ;-)

The OP can use `+.Date` directly as you suggest, or ignore the warnings
as they are harmless, or coerce the difftime object to numeric as I
suggested. It makes no odds in these cases.

I guess the main point for the OP is to realise why the warning is there
and determine if it is OK to ignore.

G