struct Quartz::Duration

• Quartz::Duration
• Struct
• Value
• Object

Overview

Duration is a fixed-point time data type which encapsulates a 64-bit binary floating-point number.

Included Modules

• Comparable(Quartz::Duration)

Defined in:

Constant Summary

EPOCH = 5

The epoch constant helps establishing the limiting multiplier of the Duration datatype together with Scale::FACTOR.

INFINITY = new(MULTIPLIER_INFINITE)

An infinite duration with a base scale.

MULTIPLIER_INFINITE = Float64::INFINITY

The infinite multiplier

MULTIPLIER_LIMIT = Scale::FACTOR ** EPOCH

The limiting multiplier of the Duration type.

The 1000^5 limit is chosen as the largest power of 1000 less than 2^53, the point at which Float64 ceases to exactly represent all integers.

MULTIPLIER_MAX = MULTIPLIER_LIMIT - 1

The largest finite multiplier that can be represented by a Duration.

MULTIPLIER_MIN = 0_i64

The smallest finite multiplier that can be represented by a Duration.

Constructors

• .new(m : Number = 0_i64, precision : Int = 0_i8, fixed : Bool = false)
• .new(m : Number = 0_i64, precision : Scale = Scale::BASE, fixed : Bool = false)

Class Method Summary

• .from(n : Float)

  Creates a Duration from a given Float between 0 and 1 and tries to assign an appropriate precision.

• .infinity(precision : Scale = Scale::BASE, fixed : Bool = false)
• .zero(precision : Scale = Scale::BASE, fixed : Bool = false)

Instance Method Summary

• #*(n : Number) : Duration

  Multiply self by the given factor n.

• #+(other : Duration) : Duration

  Adds two Durations values.

• #-(other : Duration) : Duration

  Substracts two Durations values

• #- : Duration

  Negates self.

• #/(other : Duration) : Float64

  The division of one duration by another is always considered a floating-point operation.

• #/(n : Number) : Duration

  Divide self by the given scalar operand n.

• #<=>(other : self)

  Implements the comparison operator.

• #clone

  Returns a copy of self with all instance variables cloned.

• #equals?(other : self)

  Equality — Returns true only if self and other are equivalent in both multiplier and time precision.

• #finite? : Bool

  Whether self is a finite duration.

• #fixed : Duration

  Produces a fixed but equivalent duration.

• #fixed? : Bool

  Whether self fixed or unfixed.

• #fixed_at(precision : Scale) : Duration

  Produces a fixed duration value with the specified precision level.

• #infinite? : Bool

  Whether self is an infinite duration.

• #inspect(io)
• #multiplier : Int64

  Returns the multiplier of self.

• #precision : Scale
• #rescale(precision : Scale) : Duration

  Produces a duration value with the specified precision level.

• #to_f
• #to_f32
• #to_f64
• #unfixed : Duration

  Produces an unfixed but equivalent duration.

• #zero? : Bool

  Whether self is a zero duration.

Constructor Detail

Class Method Detail

Duration.from(0.000034) # => Duration.new(34, Scale::MICRO)

Instance Method Detail