[go-nuts] How to round a Duration?

On Tuesday, September 2, 2014 11:58:01 AM UTC-4, Jan Mercl wrote:

On Tue, Sep 2, 2014 at 5:54 PM, Gary Scarr <sca...@gmail.com <javascript:>>
wrote:

secs := (duration + time.Second/2) / time.Second

-j

On Tuesday, September 2, 2014 12:38:15 PM UTC-4, Ian Davis wrote:


On Tue, Sep 2, 2014, at 04:54 PM, Gary Scarr wrote:


Am I missing an obvious way of doing this or should there be a Round
method on Duration?


A Duration is just an int64 number of nanoseconds, so you could do:

seconds := int64(time.Since(start)) / 1e9

That would give you seconds as an int64

Ian

On Tue, Sep 2, 2014 at 9:53 AM, Gary Scarr wrote:
Thanks but then I lose the inherent formatting ability of the Duration
object. Some of my durations run to hours and minutes (where even seconds
are irrelevant) and I like the built-in logic that switches the display
based upon the actual period.

--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an
email to golang-nuts+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

On 2 Sep 2014, at 17:53, Gary Scarr wrote:

Thanks but then I lose the inherent formatting ability of the Duration object. Some of my durations run to hours and minutes (where even seconds are irrelevant) and I like the built-in logic that switches the display based upon the actual period.

On Tuesday, September 2, 2014 5:52:57 PM UTC-4, Andrew Bursavich wrote:

Here's a rounding function: http://play.golang.org/p/QHocTHl8iR

On Wed, Sep 3, 2014 at 5:16 AM, Gary Scarr wrote:

Bravo Andrew!!!

This is indeed what I had been wanting: the automatic formatting range of
the existing Duration with the arbitrary precision of the Time.Round
function. With all due respect to Rob with his "Just write the code", it
didn't seem that obvious and I would certainly never have come up with
anything this elegant. My first instinct was along the lines of Jan's:(
(dur + resolution/2)/resolution) * resolution but there's no hint of a 2 in
your code so it will take me a while to grok it. But it does far better
than my simple rounding of both timing endpoints so it doesn't affect their
precision.

As is often the case, after posing my "simple" question and then being
asked "Is this what you want" it occurred to me that what might also be
useful was to print a duration with a "sensible" precision like 2 or 3
digits. Is there a way to use your function (other than a switch or
if/else chain based on the value of d) that would achieve this? I tried a
very naive making r a function of d as here where n was intended to be the
approx digits of precision but it failed horribly:
switch n {
case 1:
r = d / 10
case 2:
r = d / 100
case 3:
r = d / 1000
case 4:
r = d / 10000
case 5:
r = d / 100000
case 6:
r = d / 10000000
}

Thanks to you and all the others for your suggestions,
Gary
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an
email to golang-nuts+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

On Tuesday, September 2, 2014 8:16:04 PM UTC-7, Gary Scarr wrote:
Bravo Andrew!!!

This is indeed what I had been wanting: the automatic formatting range of
the existing Duration with the arbitrary precision of the Time.Round
function. With all due respect to Rob with his "Just write the code", it
didn't seem that obvious and I would certainly never have come up with
anything this elegant.

Thanks to you and all the others for your suggestions,
Gary

On Tuesday, 2 September 2014 18:54:27 UTC+3, Gary Scarr wrote:
To log a time difference I initially coded:


start := time.Now()
...
fmt.Printf("...took %s\n", time.Since(start))


but that resulted in an output of 19.7996387s which is impressive in its
resolution but I really only wanted a display resolution to the second.

So I thought the natural thing would be to call:

time.Since(start).Round(time.Second)

but there is no Round method on Duration, only on a Time. So I resorted
to:


start := time.Now().Round(time.Second)
...
end := := time.Now().Round(time.Second)
fmt.Printf("...took %s\n", end.Sub(start))

which gives me the requisite display of "20s" but isn't as clean or
precise as rounding the duration itself.

Am I missing an obvious way of doing this or should there be a Round
method on Duration?

Thanks,
Gary

On Tuesday, September 2, 2014 12:51:18 PM UTC-4, egon wrote:


start := time.Now()
...
diff := time.Since(start)
fmt.Printf("%v\n", diff.Nanoseconds()/time.Second.Nanoseconds())

On Tue, Sep 2, 2014 at 1:20 PM, Gary Scarr wrote:
This wins the originality prize for use of time.Seconds.Nanoseconds(). My
immediate thought was "how can you call a method on a constant?" but then I
realized "in Go you can call a method on anything". Unfortunately it also
suffers from the limitation of Ian's solution since it ends up with an
uint64. It's apparent that I didn't make clear in my original post that I
want to continue to have a Duration object (so that it can display longer
durations) but round the output to seconds.
Gary

--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an
email to golang-nuts+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.