timex v3.3.0 Timex.Duration View Source

This module provides a friendly API for working with Erlang timestamps, i.e. {megasecs, secs, microsecs}. In addition, it provides an easy way to wrap the measurement of function execution time (via measure).

Link to this section Summary

Functions

Returns the absolute value of the provided Duration

Add one Duration to another

This function determines the difference in time between two timestamps (represented by Duration structs). If the second timestamp is omitted, Duration.now will be used as the reference timestamp. If the first timestamp argument occurs before the second, the resulting measurement will be a negative value

An alias for Duration.diff/3

Returns the duration since the first day of year 0 to Epoch

Returns the amount of time since the first day of year 0 to Epoch

Converts a clock tuple, i.e. {hour, minute, second, microsecond} to a Duration

Converts an integer value representing days to a Duration

Converts an Erlang timestamp to a Duration

Converts an integer value representing hours to a Duration

Converts an integer value representing microseconds to a Duration

Converts an integer value representing milliseconds to a Duration

Converts an integer value representing minutes to a Duration

Converts an integer value representing seconds to a Duration

Converts a Time to a Duration

Converts an integer value representing weeks to a Duration

Invert a Duration, i.e. a positive duration becomes a negative one, and vice versa

Evaluates fun() and measures the elapsed time

Evaluates apply(fun, args), and measures execution time

Evaluates apply(module, fun, args), and measures execution time

Returns the amount of time since Epoch

Parses a duration string (in ISO-8601 format) into a Duration struct

Parses a duration string into a Duration struct, using the provided parser module

Same as parse/1, but returns the Duration unwrapped, and raises on error

Same as parse/2, but returns the Duration unwrapped, and raises on error

Scale a Duration by some coefficient value, i.e. a scale of 2 is twice is long

Subtract one Duration from another

Converts a Duration to a clock tuple, i.e. {hour,minute,second,microsecond}

Converts a Duration to its value in days

Converts a Duration to an Erlang timestamp

Converts a Duration to its value in hours

Converts a Duration to its value in microseconds

Converts a Duration to its value in milliseconds

Converts a Duration to its value in minutes

Converts a Duration to its value in seconds

Converts a Duration to a string, using the ISO standard for formatting durations

Converts a Duration to a Time if the duration fits within a 24-hour clock. If it does not, an error tuple is returned

Same as to_time/1, but returns the Time directly. Raises an error if the duration does not fit within a 24-hour clock

Converts a Duration to its value in weeks

Return a timestamp representing a time lapse of length 0

Link to this section Types

Link to this type measurement_units() View Source
measurement_units() ::
  :microseconds | :milliseconds | :seconds | :minutes | :hours
Link to this type t() View Source
t() :: %Timex.Duration{
  megaseconds: integer(),
  microseconds: integer(),
  seconds: integer()
}
Link to this type to_options() View Source
to_options() :: [{:truncate, boolean()}]
Link to this type units() View Source
units() ::
  :microseconds | :milliseconds | :seconds | :minutes | :hours | :days | :weeks

Link to this section Functions

Returns the absolute value of the provided Duration.

Example

iex> d = %Timex.Duration{megaseconds: -1, seconds: -2, microseconds: -3}
...> Timex.Duration.abs(d)
%Timex.Duration{megaseconds: 1, seconds: 2, microseconds: 3}

Add one Duration to another.

Examples

iex> d = %Timex.Duration{megaseconds: 1, seconds: 1, microseconds: 1}
...> Timex.Duration.add(d, d)
%Timex.Duration{megaseconds: 2, seconds: 2, microseconds: 2}

iex> d = %Timex.Duration{megaseconds: 1, seconds: 750000, microseconds: 750000}
...> Timex.Duration.add(d, d)
%Timex.Duration{megaseconds: 3, seconds: 500001, microseconds: 500000}
Link to this function diff(t1, t2, type \\ nil) View Source

This function determines the difference in time between two timestamps (represented by Duration structs). If the second timestamp is omitted, Duration.now will be used as the reference timestamp. If the first timestamp argument occurs before the second, the resulting measurement will be a negative value.

The type argument is an atom indicating the units the measurement should be returned in. If no type argument is provided, a Duration will be returned.

Valid measurement units for this function are:

:microseconds, :milliseconds, :seconds, :minutes, :hours, :days, or :weeks

Examples

iex> alias Timex.Duration
...> d = Duration.from_erl({1457, 136000, 785000})
...> Duration.diff(d, Duration.zero, :days)
16865
Link to this function elapsed(duration, ref \\ nil, type \\ nil) View Source

An alias for Duration.diff/3

Returns the duration since the first day of year 0 to Epoch.

Example

iex> Timex.Duration.epoch()
%Timex.Duration{megaseconds: 62_167, seconds: 219_200, microseconds: 0}

Returns the amount of time since the first day of year 0 to Epoch.

The argument is an atom indicating the type of time units to return.

The allowed unit type atoms are:

  • :microseconds
  • :milliseconds
  • :seconds
  • :minutes
  • :hours
  • :days
  • :weeks

Examples

iex> Timex.Duration.epoch(:seconds)
62_167_219_200

If the specified type is nil, a duration since the first day of year 0 to Epoch is returned.

iex> Timex.Duration.epoch(nil)
%Timex.Duration{megaseconds: 62_167, seconds: 219_200, microseconds: 0}

Converts a clock tuple, i.e. {hour, minute, second, microsecond} to a Duration.

Example

iex> Timex.Duration.from_clock({1, 2, 3, 4})
%Timex.Duration{megaseconds: 0, seconds: 3723, microseconds: 4}

Converts an integer value representing days to a Duration

Converts an Erlang timestamp to a Duration

Example

iex> Timex.Duration.from_erl({1, 2, 3})
%Timex.Duration{megaseconds: 1, seconds: 2, microseconds: 3}

Converts an integer value representing hours to a Duration

Link to this function from_microseconds(us) View Source
from_microseconds(integer()) :: Timex.Duration.t()

Converts an integer value representing microseconds to a Duration

Link to this function from_milliseconds(ms) View Source
from_milliseconds(integer()) :: Timex.Duration.t()

Converts an integer value representing milliseconds to a Duration

Converts an integer value representing minutes to a Duration

Converts an integer value representing seconds to a Duration

Converts a Time to a Duration

Example

iex> Timex.Duration.from_time(~T[01:01:30])
%Timex.Duration{megaseconds: 0, seconds: 3690, microseconds: 0}

Converts an integer value representing weeks to a Duration

Invert a Duration, i.e. a positive duration becomes a negative one, and vice versa

Example

iex> d = %Timex.Duration{megaseconds: -1, seconds: -2, microseconds: -3}
...> Timex.Duration.invert(d)
%Timex.Duration{megaseconds: 1, seconds: 2, microseconds: 3}
Link to this function measure(fun) View Source
measure((() -> any())) :: {Timex.Duration.t(), any()}

Evaluates fun() and measures the elapsed time.

Returns {Duration.t, result}.

Example

iex> {_timestamp, result} = Duration.measure(fn -> 2 * 2 end)
...> result == 4
true
Link to this function measure(fun, args) View Source
measure((... -> any()), [any()]) :: {Timex.Duration.t(), any()}

Evaluates apply(fun, args), and measures execution time.

Returns {Duration.t, result}.

Example

iex> {_timestamp, result} = Duration.measure(fn x, y -> x * y end, [2, 4])
...> result == 8
true
Link to this function measure(module, fun, args) View Source
measure(module(), atom(), [any()]) :: {Timex.Duration.t(), any()}

Evaluates apply(module, fun, args), and measures execution time.

Returns {Duration.t, result}.

Example

iex> {_timestamp, result} = Duration.measure(Enum, :map, [[1,2], &(&1*2)])
...> result == [2, 4]
true

Returns the amount of time since Epoch.

The argument is an atom indicating the type of time units to return.

The allowed unit type atoms are:

  • :microseconds
  • :milliseconds
  • :seconds
  • :minutes
  • :hours
  • :days
  • :weeks

Examples

iex> Timex.Duration.now(:seconds)
1483141644

When the argument is omitted or nil, a Duration is returned.

iex> Timex.Duration.now
%Timex.Duration{megaseconds: 1483, seconds: 141562, microseconds: 536938}
Link to this function parse(str) View Source
parse(String.t()) :: {:ok, Timex.Duration.t()} | {:error, term()}

Parses a duration string (in ISO-8601 format) into a Duration struct.

Link to this function parse(str, module) View Source
parse(String.t(), module()) :: {:ok, Timex.Duration.t()} | {:error, term()}

Parses a duration string into a Duration struct, using the provided parser module.

Same as parse/1, but returns the Duration unwrapped, and raises on error

Same as parse/2, but returns the Duration unwrapped, and raises on error

Link to this function scale(duration, coef) View Source
scale(Timex.Duration.t(), coefficient :: integer() | float()) ::
  Timex.Duration.t()

Scale a Duration by some coefficient value, i.e. a scale of 2 is twice is long.

Example

iex> d = %Timex.Duration{megaseconds: 1, seconds: 1, microseconds: 1}
...> Timex.Duration.scale(d, 2)
%Timex.Duration{megaseconds: 2, seconds: 2, microseconds: 2}

Subtract one Duration from another.

Example

iex> d1 = %Timex.Duration{megaseconds: 3, seconds: 3, microseconds: 3}
...> d2 = %Timex.Duration{megaseconds: 2, seconds: 2, microseconds: 2}
...> Timex.Duration.sub(d1, d2)
%Timex.Duration{megaseconds: 1, seconds: 1, microseconds: 1}

Converts a Duration to a clock tuple, i.e. {hour,minute,second,microsecond}.

Example

iex> d = %Timex.Duration{megaseconds: 1, seconds: 1, microseconds: 50}
...> Timex.Duration.to_clock(d)
{277, 46, 41, 50}

Converts a Duration to its value in days

Example

iex> Duration.to_days(Duration.from_hours(6))
0.25
iex> Duration.to_days(Duration.from_hours(25), truncate: true)
1
Link to this function to_days(d, arg2) View Source
to_days(Timex.Duration.t(), to_options()) :: float() | integer()
to_days(integer() | float(), :microseconds) :: float()
to_days(integer() | float(), :milliseconds) :: float()
to_days(integer() | float(), :seconds) :: float()
to_days(integer() | float(), :minutes) :: float()
to_days(integer() | float(), :hours) :: float()
to_days(integer() | float(), :days) :: float()
to_days(integer() | float(), :weeks) :: float()

Converts a Duration to an Erlang timestamp

Example

iex> d = %Timex.Duration{megaseconds: 1, seconds: 2, microseconds: 3}
...> Timex.Duration.to_erl(d)
{1, 2, 3}

Converts a Duration to its value in hours

Example

iex> Duration.to_hours(Duration.from_minutes(105))
1.75
iex> Duration.to_hours(Duration.from_minutes(105), truncate: true)
1
Link to this function to_hours(d, arg2) View Source
to_hours(Timex.Duration.t(), to_options()) :: float() | integer()
to_hours(integer() | float(), :microseconds) :: float()
to_hours(integer() | float(), :milliseconds) :: float()
to_hours(integer() | float(), :seconds) :: float()
to_hours(integer() | float(), :minutes) :: float()
to_hours(integer() | float(), :hours) :: float()
to_hours(integer() | float(), :days) :: float()
to_hours(integer() | float(), :weeks) :: float()
Link to this function to_microseconds(duration) View Source
to_microseconds(Timex.Duration.t()) :: integer()

Converts a Duration to its value in microseconds

Example

iex> Duration.to_microseconds(Duration.from_milliseconds(10.5))
10_500
Link to this function to_microseconds(duration, arg2) View Source
to_microseconds(Timex.Duration.t(), to_options()) :: integer()
to_microseconds(integer() | float(), :microseconds) :: float()
to_microseconds(integer() | float(), :milliseconds) :: float()
to_microseconds(integer() | float(), :seconds) :: float()
to_microseconds(integer() | float(), :minutes) :: float()
to_microseconds(integer() | float(), :hours) :: float()
to_microseconds(integer() | float(), :days) :: float()
to_microseconds(integer() | float(), :weeks) :: float()
Link to this function to_milliseconds(d) View Source
to_milliseconds(Timex.Duration.t()) :: float()

Converts a Duration to its value in milliseconds

Example

iex> Duration.to_milliseconds(Duration.from_seconds(1))
1000.0
iex> Duration.to_milliseconds(Duration.from_seconds(1.543))
1543.0
iex> Duration.to_milliseconds(Duration.from_seconds(1.543), truncate: true)
1543
Link to this function to_milliseconds(d, arg2) View Source
to_milliseconds(Timex.Duration.t(), to_options()) :: float() | integer()
to_milliseconds(integer() | float(), :microseconds) :: float()
to_milliseconds(integer() | float(), :milliseconds) :: float()
to_milliseconds(integer() | float(), :seconds) :: float()
to_milliseconds(integer() | float(), :minutes) :: float()
to_milliseconds(integer() | float(), :hours) :: float()
to_milliseconds(integer() | float(), :days) :: float()
to_milliseconds(integer() | float(), :weeks) :: float()

Converts a Duration to its value in minutes

Example

iex> Duration.to_minutes(Duration.from_seconds(90))
1.5
iex> Duration.to_minutes(Duration.from_seconds(65), truncate: true)
1
Link to this function to_minutes(d, arg2) View Source
to_minutes(Timex.Duration.t(), to_options()) :: float() | integer()
to_minutes(integer() | float(), :microseconds) :: float()
to_minutes(integer() | float(), :milliseconds) :: float()
to_minutes(integer() | float(), :seconds) :: float()
to_minutes(integer() | float(), :minutes) :: float()
to_minutes(integer() | float(), :hours) :: float()
to_minutes(integer() | float(), :days) :: float()
to_minutes(integer() | float(), :weeks) :: float()

Converts a Duration to its value in seconds

Example

iex> Duration.to_seconds(Duration.from_milliseconds(1500))
1.5
iex> Duration.to_seconds(Duration.from_milliseconds(1500), truncate: true)
1
Link to this function to_seconds(d, arg2) View Source
to_seconds(Timex.Duration.t(), to_options()) :: float() | integer()
to_seconds(integer() | float(), :microseconds) :: float()
to_seconds(integer() | float(), :milliseconds) :: float()
to_seconds(integer() | float(), :seconds) :: float()
to_seconds(integer() | float(), :minutes) :: float()
to_seconds(integer() | float(), :hours) :: float()
to_seconds(integer() | float(), :days) :: float()
to_seconds(integer() | float(), :weeks) :: float()

Converts a Duration to a string, using the ISO standard for formatting durations.

Examples

iex> d = %Timex.Duration{megaseconds: 0, seconds: 3661, microseconds: 0}
...> Timex.Duration.to_string(d)
"PT1H1M1S"

iex> d = %Timex.Duration{megaseconds: 102, seconds: 656013, microseconds: 33}
...> Timex.Duration.to_string(d)
"P3Y3M3DT3H33M33.000033S"
Link to this function to_time(d) View Source
to_time(Timex.Duration.t()) :: {:ok, Time.t()} | {:error, atom()}

Converts a Duration to a Time if the duration fits within a 24-hour clock. If it does not, an error tuple is returned.

Examples

iex> d = %Timex.Duration{megaseconds: 0, seconds: 4000, microseconds: 0}
...> Timex.Duration.to_time(d)
{:ok, ~T[01:06:40]}

iex> d = %Timex.Duration{megaseconds: 1, seconds: 0, microseconds: 0}
...> Timex.Duration.to_time(d)
{:error, :invalid_time}

Same as to_time/1, but returns the Time directly. Raises an error if the duration does not fit within a 24-hour clock.

Examples

iex> d = %Timex.Duration{megaseconds: 0, seconds: 4000, microseconds: 0}
...> Timex.Duration.to_time!(d)
~T[01:06:40]

iex> d = %Timex.Duration{megaseconds: 1, seconds: 0, microseconds: 0}
...> Timex.Duration.to_time!(d)
** (ArgumentError) cannot convert {277, 46, 40} to time, reason: :invalid_time

Converts a Duration to its value in weeks

Example

iex> Duration.to_weeks(Duration.from_days(14))
2.0
iex> Duration.to_weeks(Duration.from_days(13), truncate: true)
1
Link to this function to_weeks(d, arg2) View Source
to_weeks(Timex.Duration.t(), to_options()) :: float() | integer()
to_weeks(integer() | float(), :microseconds) :: float()
to_weeks(integer() | float(), :milliseconds) :: float()
to_weeks(integer() | float(), :seconds) :: float()
to_weeks(integer() | float(), :minutes) :: float()
to_weeks(integer() | float(), :hours) :: float()
to_weeks(integer() | float(), :days) :: float()
to_weeks(integer() | float(), :weeks) :: float()

Return a timestamp representing a time lapse of length 0.

iex> Timex.Duration.zero |> Timex.Duration.to_seconds
0.0

Can be useful for operations on collections of durations. For instance,

Enum.reduce(durations, Duration.zero, Duration.add(&1, &2))

Can also be used to represent the timestamp of the start of the UNIX epoch, as all Erlang timestamps are relative to this point.