require 'date'
class Time
  def to_datetime
    # Convert seconds + microseconds into a fractional number of seconds
    seconds = sec + Rational(usec, 10**6)    
    # Convert a UTC offset measured in minutes to one measured in a
    # fraction of a day.
    offset = Rational(utc_offset, 60 * 60 * 24)
    DateTime.new(year, month, day, hour, min, seconds, offset)
  end
end
time = Time.gm(2000, 6, 4, 10, 30, 22, 4010)    

time.to_datetime.to_s

class Date
  def to_gm_time
    to_time(new_offset, :gm)
  end
  def to_local_time
    to_time(new_offset(DateTime.now.offset-offset), :local)
  end
  private
  def to_time(dest, method)
    #Convert a fraction of a day to a number of microseconds
    usec = (dest.sec_fraction * 60 * 60 * 24 * (10**6)).to_i
    Time.send(method, dest.year, dest.month, dest.day, dest.hour, dest.min,
              dest.sec, usec)   
  end
end
(datetime = DateTime.new(1990, 10, 1, 22, 16, Rational(41,2))).to_s

datetime.to_gm_time

datetime.to_local_time

time < datetime

ArgumentError: comparison of Time with DateTime failed
...

ArgumentError: comparison of Time with DateTime failed
	from (irb):32:in `<'
	from (irb):32

time.to_datetime < datetime

time < datetime.to_gm_time

time - datetime

TypeError: can't convert DateTime into Float
...

TypeError: can't convert DateTime into Float
	from (irb):35:in `-'
	from (irb):35

(time.to_datetime - datetime).to_f

time - datetime.to_gm_time

time

time.usec

time.to_datetime.to_gm_time

time.to_datetime.to_gm_time.usec

datetime.to_s

datetime.to_gm_time.to_datetime.to_s

def normalize_time_types(array)
  # Don't do anything if all the objects are already of the same type.
  first_class = array[0].class
  first_class = first_class.super if first_class == DateTime
  return unless array.detect { |x| !x.is_a?(first_class) }
  normalized = array.collect do |t| 
    if t.is_a?(Date)
      begin 
        t.to_local_time
      rescue ArgumentError # Time out of range; convert to DateTimes instead.
        convert_to = DateTime
        break
      end
    else
      t
    end
  end
  unless normalized
    normalized = array.collect { |t| t.is_a?(Time) ? t.to_datetime : t }
  end
  return normalized
end
mixed_array = [Time.now, DateTime.now]

normalize_time_types(mixed_array)

mixed_array << DateTime.civil(1776, 7, 4)
normalize_time_types(mixed_array).collect { |x| x.to_s }