How to compare time of last file modification?

[Thorsten Jolitz]

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?

--
cheers,
Thorsten

[Thorsten Jolitz]

Ups, I just found the function 'file-newer-than-file-p' that solves my
problem. Sorry for the noise.

--
cheers,
Thorsten

[Pascal J. Bourguignon]

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)))))))


--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.

[Thorsten Jolitz]

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

[Michael Albinus]

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

> (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)))))))

In Tramp, we use

(defun tramp-time-less-p (t1 t2)
"Say whether time value T1 is less than time value T2."
(unless t1 (setq t1 '(0 0)))
(unless t2 (setq t2 '(0 0)))
(or (< (car t1) (car t2))
(and (= (car t1) (car t2))
(< (nth 1 t1) (nth 1 t2)))))

Best regards, Michael.

[Lars Magne Ingebrigtsen]

Thorsten Jolitz <tjo...@googlemail.com> writes:

> If I want to compare the time of last modification of two files - how do
> I do that, using these two integers?

Use `time-less-p':

time-less-p is a compiled Lisp function in `time-date.el'.

(time-less-p T1 T2)

Return non-nil if time value T1 is earlier than time value T2.

--
(domestic pets only, the antidote for overdose, milk.)
bloggy blog http://lars.ingebrigtsen.no/

[Thorsten Jolitz]

Lars Magne Ingebrigtsen <l...@gnus.org> writes:

> Thorsten Jolitz <tjo...@googlemail.com> writes:
>

>> If I want to compare the time of last modification of two files - how do
>> I do that, using these two integers?
>

> Use `time-less-p':
>
> time-less-p is a compiled Lisp function in `time-date.el'.
>
> (time-less-p T1 T2)
>
> Return non-nil if time value T1 is earlier than time value T2.

Thanks to everybody for several solutions.
Is there a reason to prefer time-less-p or the custom-made solutions
over file-newer-than-file-p?

--
cheers,
Thorsten

[Pascal J. Bourguignon]

Thorsten Jolitz <tjo...@googlemail.com> writes:

> Is there a reason to prefer time-less-p or the custom-made solutions
> over file-newer-than-file-p?

file-newer-than-file-p use the OS provided m_time types to compare.
time-less-p uses a 1-second resolution, 32-bit representation of time.
Therefore?

[Barry Margolin]

In article <mailman.3833.13411634...@gnu.org>,

Thorsten Jolitz <tjo...@googlemail.com> wrote:

> Is there a reason to prefer time-less-p or the custom-made solutions
> over file-newer-than-file-p?

file-newer-than-file-p is only applicable when you're comparing two
files. If you're comparing a file's modification time to some other
time, then you need to use time-less-p.

--
Barry Margolin, bar...@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***

[Thorsten Jolitz]

Barry Margolin <bar...@alum.mit.edu> writes:

> In article <mailman.3833.13411634...@gnu.org>,
> Thorsten Jolitz <tjo...@googlemail.com> wrote:
>
>> Is there a reason to prefer time-less-p or the custom-made solutions
>> over file-newer-than-file-p?
>
> file-newer-than-file-p is only applicable when you're comparing two
> files. If you're comparing a file's modification time to some other
> time, then you need to use time-less-p.

I see, thanks.

--
cheers,
Thorsten

[Lars Magne Ingebrigtsen]

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

> file-newer-than-file-p use the OS provided m_time types to compare.
> time-less-p uses a 1-second resolution, 32-bit representation of time.

No, `time-less-p' (now) uses the resolution that the OS exposes to
Emacs, which, on most OS-es, is a lot more fine-grained than 1 second.