Re: How to compare time of last file modification?

[Thorsten Jolitz]

"Pascal J. Bourguignon" <pjb@informatimago.com> writes:

> Thorsten Jolitz <tjolitz@googlemail.com> writes:
>
>> Hi List, 
>> the Elisp manual tells me about file-attributes:
>>
>>
>>      4. The time of last access, as a list of two integers. The
>>         first integer has the high-order 16 bits of time, the
>>         second has the low 16 bits. (This is similar to the value
>>         of current-time; see Time of Day.) Note that on some
>>         FAT-based filesystems, only the date of last access is
>>         recorded, so this time will always hold the midnight of the
>>         day of last access.
>>        
>>      5. The time of last modification as a list of two integers (as
>>         above). This is the last time when the file's contents were
>>         modified.
>>
>>
>> If I want to compare the time of last modification of two files - how do
>> I do that, using these two integers? 
>
> You have to apply some powerful magic, called "maths".
>
> If I were you, I'd not read the following of that message, it's much too
> esoteric.
>
>
>
> The first time is characterized with this system of equations:
>
>   t₁ =  65536×h₁ + l₁
>   0 ≤ h₁ < 65536
>   0 ≤ l₁ < 65536
>
> The second time with this similar system:
>
>   t₂ =  65536×h₂ + l₂
>   0 ≤ h₂ < 65536
>   0 ≤ l₂ < 65536
>
>
> Comparing those times is adding this equation to the above system:
>
>   t₁ < t₂
>   t₁ =  65536×h₁ + l₁
>   0 ≤ h₁ < 65536
>   0 ≤ l₁ < 65536
>   t₂ =  65536×h₂ + l₂
>   0 ≤ h₂ < 65536
>   0 ≤ l₂ < 65536
>
> So we have to solve a system of equations with 3 variables and 7
> equations.
>
> I told you do not read further!
>
>
>               t₁ < t₂           ∧  t₁ =  65536×h₁ + l₁ ∧  t₂ =  65536×h₂ + l₂
>   ⇔  65536×h₁+l₁ < 65536×h₂+l₂  ∧  t₁ =  65536×h₁ + l₁ ∧  t₂ =  65536×h₂ + l₂
>
>
> Now, notice that: 
>
>       ∀n, 65536×(n+1) + 0 > 65536×n + 65535
>   ⇔  ∀n, 65536×n + 65536 > 65536×n + 65535
>   ⇔  ∀n,           65536 > 65535
>   ⇔  true
>
> Similarly, 
>
>       ∀n,p  n > p ⇒ 65536×n + 0          > 65536×p + 65535
>   ⇔  ∀n,p  n > p ⇒ 65536×(n-p+p)        > 65536×p + 65535
>   ⇔  ∀n,p  n > p ⇒ 65536×(n-p)+65536×p  > 65536×p + 65535
>   ⇔  ∀n,p  n > p ⇒ 65536×(n-p) > 65535
>   ⇔  ∀n,p  n > p ⇒ 65536×(n-p) ≥ 65536 > 65535
>   ⇔  ∀n,p  n > p ⇒ true
>   ⇔  true
>
> Therefore, if h₂ > h₁ then t₂ > t₁
>        and if h₁ > h₂ then t₁ > t₂
>
> Now, if h₂ = h₁, then 
>
>         t₁ < t₂ ∧ t₁ =  65536×h₁ + l₁ ∧ t₂ =  65536×h₂ + l₂ ∧ h₁ = h₂
>
>   ⇔  65536×h₁+l₁ < 65536×h₁+l₂  ∧  t₁ =  65536×h₁ + l₁ 
>                                ∧  t₂ =  65536×h₂ + l₂ ∧ h₁ = h₂
>
>   ⇔  l₁ < l₂  ∧  t₁ =  65536×h₁ + l₁ ∧  t₂ =  65536×h₂ + l₂ ∧ h₁ = h₂
>
>
> Therefore, if h₂ > h₁ then t₂ > t₁
>            if h₁ > h₂ then t₁ > t₂
>            if h₁ = h₂ then if l₁ < l₂ then t₁ < t₂
>                           if l₁ > l₂ then t₁ > t₂
>                           if l₁ = l₂ then t₁ = t₂
>
> Does this look like an "algorithms"?  I told you, dark magic here!
>
>
>     (defun time-lessp (t1 t2)
>       "Returns whether t1<t2
>     t1 and t2 are lists of two integers. The first integer has the
>     high-order 16 bits of time, the second has the low 16 bits."
>       (destructuring-bind (h1 l1) t1
>         (destructuring-bind (h2 l2) t2
>            (cond
>              ((< h1 h2) t)
>              ((> h1 h2) nil)
>              (t (cond ((< l1 l2) t)
>                       (t         nil)))))))

I knew there is a simple and intuitive solution ;)

While the math part does look a bit esoteric, your function is similar
to what I would have expected as a solution. But I wasn't really sure
how to interpret these integers, and probably would have needed much
more lines of code myself to write something similar.

Thank you.

-- 
cheers,
Thorsten