 # Timex compare

Hi, all,

i’m trying compare with timex variables,
but i don’t know why this code work like that…

``````
dts = Timex.parse!( "2019-01-01T00:00:00.000Z", "{ISO:Extended:Z}" )
now = Timex.parse!( "2019-01-01T00:00:00.100Z", "{ISO:Extended:Z}" )

dt = Timex.shift( dts, seconds: 5 )

if ( dt <= now ) do
raise ( "why? dt already shift seconds... dt[#{ inspect dt }] now[#{ inspect now }]" )
else
:ok
end

``````

I thought that such a comparison should be the opposite result…

anyone can help me to understand this? thanks

You need to use `Timex.compare/2/3` instead of `Kernel.<=/2`.

3 Likes

The built in comparison operators aren’t the right tool for this job. You probably want to use Timex.compare/3.

For an explanation of why this is the case you might find this useful. Especially this quote:

Maps are compared by size, then by keys in ascending term order, then by values in key order. In the specific case of maps’ key ordering, integers are always considered to be less than floats.

2 Likes

okay thank you guys,

so i need change my code to

``````#if ( dt <= now ) do
compared = Timex.compare( dt, now )
if ( compared == 0 || compared == -1 ) do
``````

right?

@kip thank you for explanation i was wrong a test to make sure my project working… but seem not work ``````test "compare with operations" do

#equal
a = Timex.parse!( "2017-01-01T01:00:00.751Z", "{ISO:Extended:Z}" )
b = Timex.parse!( "2017-01-01T01:00:00.751Z", "{ISO:Extended:Z}" )
assert( a == b )
assert( ( a < b ) == false )
assert( ( a > b ) == false )
assert( ( a <= b ) == true )
assert( ( a >= b ) == true )

#offset 1ms
a = Timex.parse!( "2017-01-01T01:00:00.750Z", "{ISO:Extended:Z}" )
b = Timex.parse!( "2017-01-01T01:00:00.751Z", "{ISO:Extended:Z}" )
assert( ( a == b ) == false )
assert( ( a < b )  == true )
assert( ( a > b )  == false )
assert( ( a <= b ) == true )
assert( ( a >= b ) == false )

#offset 5secs
a = Timex.parse!( "2019-01-01T00:00:00.000Z", "{ISO:Extended:Z}" )
a = Timex.parse!( "2019-01-01T00:00:05.000Z", "{ISO:Extended:Z}" )
assert( ( a == b ) == false )
assert( ( a < b )  == true )
assert( ( a > b )  == false )
assert( ( a <= b ) == true )
assert( ( a >= b ) == false )
end
``````

I need to add this paragraph to remind me of myself ``````#Tips: the operation compare will fail with milliseconds, instead by Timex.compare
a = Timex.parse!( "2019-01-01T00:00:05.000Z", "{ISO:Extended:Z}" )
b = Timex.parse!( "2019-01-01T00:00:00.100Z", "{ISO:Extended:Z}" )

assert( ( a == b ) == false )
assert( ( a <= b ) == true )	# it's wrong, normally it's should be false
``````

thanks guys I tend to always use the regular comparison operators against `0`.

``````Timex.compare(start, end) <= 0
``````

This does match semantics very well.

4 Likes

This is indeed a very good suggestion, thank you 