summaryrefslogtreecommitdiff
path: root/lib/date/delta.rb
diff options
context:
space:
mode:
Diffstat (limited to 'lib/date/delta.rb')
-rw-r--r--lib/date/delta.rb431
1 files changed, 0 insertions, 431 deletions
diff --git a/lib/date/delta.rb b/lib/date/delta.rb
deleted file mode 100644
index e524cbc324e..00000000000
--- a/lib/date/delta.rb
+++ /dev/null
@@ -1,431 +0,0 @@
-# delta.rb: Written by Tadayoshi Funaba 2004-2010
-
-require 'date'
-require 'date/delta/parser'
-
-class Date
-
- class Delta # :nodoc:
-
- include Comparable
-
- UNIT_PREFIXES = {
- 'yotta' => Rational(10**24),
- 'zetta' => Rational(10**21),
- 'exa' => Rational(10**18),
- 'peta' => Rational(10**15),
- 'tera' => Rational(10**12),
- 'giga' => Rational(10**9),
- 'mega' => Rational(10**6),
- 'kilo' => Rational(10**3),
- 'hecto' => Rational(10**2),
- 'deca' => Rational(10**1),
- 'deka' => Rational(10**1),
- 'deci' => Rational(1, 10**1),
- 'centi' => Rational(1, 10**2),
- 'milli' => Rational(1, 10**3),
- 'decimilli' => Rational(1, 10**4),
- 'centimilli' => Rational(1, 10**5),
- 'micro' => Rational(1, 10**6),
- 'nano' => Rational(1, 10**9),
- 'millimicro' => Rational(1, 10**9),
- 'pico' => Rational(1, 10**12),
- 'micromicro' => Rational(1, 10**12),
- 'femto' => Rational(1, 10**15),
- 'atto' => Rational(1, 10**18),
- 'zepto' => Rational(1, 10**21),
- 'yocto' => Rational(1, 10**24)
- }
-
- IUNITS = {
- 'year' => Complex(0, 12),
- 'month' => Complex(0, 1)
- }
-
- RUNITS = {
- 'day' => Rational(1),
- 'week' => Rational(7),
- 'sennight' => Rational(7),
- 'fortnight' => Rational(14),
- 'hour' => Rational(1, 24),
- 'minute' => Rational(1, 1440),
- 'second' => Rational(1, 86400)
- }
-
- UNIT_PREFIXES.each do |k, v|
- RUNITS[k + 'second'] = v * RUNITS['second']
- end
-
- remove_const :UNIT_PREFIXES
-
- UNITS = {}
-
- IUNITS.each do |k, v|
- UNITS[k] = v
- end
-
- RUNITS.each do |k, v|
- UNITS[k] = v
- end
-
- UNITS4KEY = {}
-
- UNITS.each do |k, v|
- UNITS4KEY[k] = UNITS4KEY[k + 's'] = v
- end
-
- UNITS4KEY['y'] = UNITS4KEY['years']
- UNITS4KEY['yr'] = UNITS4KEY['years']
- UNITS4KEY['yrs'] = UNITS4KEY['years']
- UNITS4KEY['m'] = UNITS4KEY['months']
- UNITS4KEY['mo'] = UNITS4KEY['months']
- UNITS4KEY['mon'] = UNITS4KEY['months']
- UNITS4KEY['mnth'] = UNITS4KEY['months']
- UNITS4KEY['mnths'] = UNITS4KEY['months']
- UNITS4KEY['w'] = UNITS4KEY['weeks']
- UNITS4KEY['wk'] = UNITS4KEY['weeks']
- UNITS4KEY['d'] = UNITS4KEY['days']
- UNITS4KEY['dy'] = UNITS4KEY['days']
- UNITS4KEY['dys'] = UNITS4KEY['days']
- UNITS4KEY['h'] = UNITS4KEY['hours']
- UNITS4KEY['hr'] = UNITS4KEY['hours']
- UNITS4KEY['hrs'] = UNITS4KEY['hours']
- UNITS4KEY['min'] = UNITS4KEY['minutes']
- UNITS4KEY['mins'] = UNITS4KEY['minutes']
- UNITS4KEY['s'] = UNITS4KEY['seconds']
- UNITS4KEY['sec'] = UNITS4KEY['seconds']
- UNITS4KEY['secs'] = UNITS4KEY['seconds']
- UNITS4KEY['ms'] = UNITS4KEY['milliseconds']
- UNITS4KEY['msec'] = UNITS4KEY['milliseconds']
- UNITS4KEY['msecs'] = UNITS4KEY['milliseconds']
- UNITS4KEY['milli'] = UNITS4KEY['milliseconds']
- UNITS4KEY['us'] = UNITS4KEY['microseconds']
- UNITS4KEY['usec'] = UNITS4KEY['microseconds']
- UNITS4KEY['usecs'] = UNITS4KEY['microseconds']
- UNITS4KEY['micro'] = UNITS4KEY['microseconds']
- UNITS4KEY['ns'] = UNITS4KEY['nanoseconds']
- UNITS4KEY['nsec'] = UNITS4KEY['nanoseconds']
- UNITS4KEY['nsecs'] = UNITS4KEY['nanoseconds']
- UNITS4KEY['nano'] = UNITS4KEY['nanoseconds']
-
- def self.delta_to_dhms(delta)
- fr = delta.imag.abs
- y, fr = fr.divmod(12)
- m, fr = fr.divmod(1)
-
- if delta.imag < 0
- y = -y
- m = -m
- end
-
- fr = delta.real.abs
- ss, fr = fr.divmod(SECONDS_IN_DAY) # 4p
- d, ss = ss.divmod(86400)
- h, ss = ss.divmod(3600)
- min, s = ss.divmod(60)
-
- if delta.real < 0
- d = -d
- h = -h
- min = -min
- s = -s
- end
-
- return y, m, d, h, min, s, fr
- end
-
- def self.dhms_to_delta(y, m, d, h, min, s, fr)
- fr = 0 if fr == 0
- Complex(0, y.to_i * 12 + m.to_i) +
- Rational(d * 86400 + h * 3600 + min * 60 + (s + fr), 86400) # 4p
- end
-
- def initialize(delta)
- @delta = delta
- @__ca__ = {}
- end
-
- class << self; alias_method :new!, :new end
-
- def self.new(arg=0, h=0, min=0, s=0)
- if Hash === arg
- d = Complex(0)
- arg.each do |k, v|
- k = k.to_s.downcase
- unless UNITS4KEY[k]
- raise ArgumentError, "unknown keyword #{k}"
- end
- d += v * UNITS4KEY[k]
- end
- else
- d = dhms_to_delta(0, 0, arg, h, min, s, 0)
- end
- new!(d)
- end
-
- UNITS.each_key do |k|
- module_eval <<-"end;"
- def self.#{k}s(n=1)
- new(:d=>n * UNITS['#{k}'])
- end
- end;
- end
-
- class << self; alias_method :mins, :minutes end
- class << self; alias_method :secs, :seconds end
-
- def self.parse(str)
- d = begin (@@pa ||= Parser.new).parse(str)
- rescue Racc::ParseError
- raise ArgumentError, 'syntax error'
- end
- new!(d)
- end
-
- def self.diff(d1, d2) new(d1.ajd - d2.ajd) end
-
- class << self
-
- def once(*ids) # :nodoc: -- restricted
- for id in ids
- module_eval <<-"end;"
- alias_method :__#{id.object_id}__, :#{id.to_s}
- private :__#{id.object_id}__
- def #{id.to_s}(*args)
- @__ca__[#{id.object_id}] ||= __#{id.object_id}__(*args)
- end
- end;
- end
- end
-
- private :once
-
- end
-
- def dhms() self.class.delta_to_dhms(@delta) end
-
- once :dhms
-
- def delta() @delta end
-
- protected :delta
-
- def years() dhms[0] end
- def months() dhms[1] end
- def days() dhms[2] end
- def hours() dhms[3] end
- def minutes() dhms[4] end
- def seconds() dhms[5] end
- def second_fractions() dhms[6] end
-
- alias_method :mins, :minutes
- alias_method :secs, :seconds
- alias_method :sec_fractions, :second_fractions
-
- RUNITS.each_key do |k|
- module_eval <<-"end;"
- def in_#{k}s(u=1)
- if @delta.imag != 0
- raise ArgumentError, "#{k}: #{self} has month"
- end
- @delta.real / (u * RUNITS['#{k}'])
- end
- end;
- end # <<dummy
-
- alias_method :in_mins, :in_minutes
- alias_method :in_secs, :in_seconds
-
- def zero?() @delta.zero? end
- def nonzero?() unless zero? then self end end
-
- def integer? () @delta.imag == 0 && @delta.real.integer? end
-
- def -@ () self.class.new!(-@delta) end
- def +@ () self.class.new!(+@delta) end
-
- def dx_addsub(m, n)
- case n
- when Numeric; return self.class.new!(@delta.__send__(m, n))
- when Delta; return self.class.new!(@delta.__send__(m, n.delta))
- else
- l, r = n.coerce(self)
- return l.__send__(m, r)
- end
- end
-
- private :dx_addsub
-
- def + (n) dx_addsub(:+, n) end
- def - (n) dx_addsub(:-, n) end
-
- def dx_muldiv(m, n)
- case n
- when Numeric
- return self.class.new!(@delta.__send__(m, n))
- else
- l, r = n.coerce(self)
- return l.__send__(m, r)
- end
- end
-
- private :dx_muldiv
-
- def * (n) dx_muldiv(:*, n) end
- def / (n) dx_muldiv(:/, n) end
-
- def dx_conv1(m, n)
- if @delta.imag != 0
- raise ArgumentError, "#{m}: #{self} has month"
- end
- case n
- when Numeric
- return self.class.new!(Complex(@delta.real.__send__(m, n), 0))
- else
- l, r = n.coerce(self)
- return l.__send__(m, r)
- end
- end
-
- private :dx_conv1
-
- def % (n) dx_conv1(:%, n) end
-
- def div(n) dx_conv1(:div, n) end
- def modulo(n) dx_conv1(:modulo, n) end
- def divmod(n) [div(n), modulo(n)] end
-
- def quotient(n)
- if @delta.imag != 0
- raise ArgumentError, "quotient: #{self} has month"
- end
- case n
- when Numeric
- return self.class.new!(Complex((@delta.real / n).truncate))
- else
- l, r = n.coerce(self)
- return l.__send__(m, r)
- end
- end
-
- def remainder(n) dx_conv1(:remainder, n) end
- def quotrem(n) [quotient(n), remainder(n)] end
-
- def ** (n) dx_conv1(:**, n) end
- def quo(n) dx_muldiv(:quo, n) end
-
- def <=> (other)
- if @delta.imag != 0
- raise ArgumentError, "<=>: #{self} has month"
- end
- case other
- when Numeric; return @delta.real <=> other
- when Delta; return @delta.real <=> other.delta.real
- else
- begin
- l, r = other.coerce(self)
- return l <=> r
- rescue NoMethodError
- end
- end
- nil
- end
-
- def == (other)
- case other
- when Numeric; return @delta == other
- when Delta; return @delta == other
- else
- begin
- l, r = other.coerce(self)
- return l == r
- rescue NoMethodError
- end
- end
- nil
- end
-
- def coerce(other)
- case other
- when Numeric; return other, @delta
- else
- super
- end
- end
-
- def eql? (other) Delta === other && self == other end
- def hash() @delta.hash end
-
- def dx_conv0(m)
- if @delta.imag != 0
- raise ArgumentError, "#{m}: #{self} has month"
- end
- @delta.real.__send__(m)
- end
-
- private :dx_conv0
-
- def abs() dx_conv0(:abs) end
-
- def ceil() dx_conv0(:ceil) end
- def floor() dx_conv0(:floor) end
- def round() dx_conv0(:round) end
- def truncate() dx_conv0(:truncate) end
-
- def to_i() dx_conv0(:to_i) end
- def to_f() dx_conv0(:to_f) end
- def to_r() dx_conv0(:to_r) end
- def to_c() @delta end
-
- alias_method :to_int, :to_i
-
- def inspect() format('#<%s: %s (%s)>', self.class, to_s, @delta) end
-
- def to_s
- format(%(%s(%dd %.02d:%02d'%02d"%03d)%s(%dy %dm)), # '
- if @delta.real < 0 then '-' else '+' end,
- days.abs, hours.abs, mins.abs, secs.abs, sec_fractions.abs * 1000,
- if @delta.imag < 0 then '-' else '+' end,
- years.abs, months.abs)
- end
-
- def marshal_dump() @delta end
-
- def marshal_load(a)
- @delta = a
- @__ca__ = {}
- end
-
- end
-
-end
-
-vsave = $VERBOSE
-$VERBOSE = false
-
-class Date
-
- def + (n)
- case n
- when Numeric; return self.class.new!(@ajd + n, @of, @sg)
- when Delta
- d = n.__send__(:delta)
- return (self >> d.imag) + d.real
- end
- raise TypeError, 'expected numeric'
- end
-
- def - (x)
- case x
- when Numeric; return self.class.new!(@ajd - x, @of, @sg)
- when Date; return @ajd - x.ajd
- when Delta
- d = x.__send__(:delta)
- return (self << d.imag) - d.real
- end
- raise TypeError, 'expected numeric'
- end
-
-end
-
-$VERBOSE = vsave