How to simplify expression with "int", modulus, and division? - algorithm

Question

The below script calculates the time difference in decimal number, but I get a rounding error, so I guess it is because of my very bad conversion at the end.
Question
Something tells me, that the expression can be simplified, but what are the math rules in this particular situation, when I have int, modulus and division?
#!/usr/bin/perl
print f("9:00", "16:45");
sub f {
my $t1 = shift #_;
my $t2 = shift #_;
my $m1 = $1*60+$2 if $t1 =~ m/(\d\d?):(\d\d?)/;
my $m2 = $1*60+$2 if $t2 =~ m/(\d\d?):(\d\d?)/;
my $h = int(($m2-$m1)/60);
return $h + ($h*60+$m2-$m1)%60/60;
}

Answer 1

You have already correctly calculated $m1 and $m2 as minutes elapsed since midnight. So why not return the time difference in fractional hours as simply:
return ($m2 - $m1) / 60.0;
As far as the "math rules," maybe it will help to look at your return versus mine and see why they are equivalent (ignoring rounding):
$h + ($h * 60 + $m2 - $m1) % 60 / 60
Notice that ($h * 60) % 60 is zero, so this term essentially drops out, leaving:
$h + ($m2 - $m1) % 60 / 60
Now think about how $h was calculated: it is the quotient of ($m2 - $m1) divided by 60, dropping the remainder (because of int()). On the other hand, ($m2 - $m1) % 60 is exactly the remainder of this division. So the expression above is essentially just adding the remainder fraction, which you dropped from $h, back in. Therefore it has the same result as
($m2 - $m1) / 60

Answer 2

You can use Time::Piece to do simple date/time calculations:
#!/usr/bin/perl
use strict;
use warnings;
use Time::Piece;
my $pattern = '%H:%M';
my $start = Time::Piece->strptime('09:00', $pattern);
my $end = Time::Piece->strptime('16:45', $pattern);
my $diff = $end - $start;
print $diff->hours;
Output:
7.75
Note that $diff is actually a Time::Seconds object.

Answer 3

I would say to use Time::Piece, but I assume this is some sort of exercise.
In Unix, all dates are converted to seconds since the epoch. It makes it easy to do arithmetic on stuff when everything is in the same units. Therefore, I would convert the times to minutes, do your operations, then convert the time back to hours and minutes. That would mean you need to subroutines. One to convert the time from hours and minutes to minutes. And one to convert from minutes to hours and minutes.
#! /usr/bin/env perl
#
use warnings;
use strict;
use feature qw(say);
my $time1 = "9:50";
my $time2 = "16:45";
my $time1_in_minutes = convert_to_minutes( $time1 );
my $time2_in_minutes = convert_to_minutes( $time2 );
my $diff_in_minutes = $time2_in_minutes - $time1_in_minutes;
say convert_to_hours( $diff_in_minutes );
sub convert_to_minutes {
my $time = shift;
my ($hours, $minutes) = split /:/, $time;
my $total_minutes = ( $hours * 60 ) + $minutes;
return $total_minutes;
}
sub convert_to_hours {
my $minutes = shift;
my $hours = int $minutes / 60;
$minutes = $minutes % 60;
return sprintf "%d:%02d", $hours, $minutes;
}
By breaking down the work into two subroutines, you can easily see what is going on. Plus, you have a lot more flexibility. What if I gave you times it took for me to run a marathon, and I want the average time? You could use the same two routines. What if I gave you the time I spent at work each day, and I wanted a total? Again, you could use the same subroutines.
And, because it's much easier to see what's going on, it's easier to correct errors that crop up when you program. Even better, because the operations are clean, I can start adding features. For example, it would be nice to check my input. In my convert_to_minutes subroutine, I might want to make sure that the hours and minutes are valid. That there's a colon in the middle. That the minutes aren't greater than 60.