workpattern 0.3.4 → 0.6.0

data/Rakefile

@@ -9,3 +9,12 @@ Rake::TestTask.new do |test|
   test.test_files = Dir["test/test_*.rb"]
   test.verbose = true
 end
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'workpattern' # You know what to do.
+  ARGV.clear
+  IRB.start
+end
+

data/lib/workpattern.rb

@@ -3,148 +3,88 @@
 #
 # email: barrie@callenb.org
 #++
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__)) unless
+  $LOAD_PATH.include?(File.dirname(__FILE__)) || $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'rubygems'
+require 'sorted_set' if RUBY_VERSION >= "2.4"
 require 'date'
-require 'workpattern/utility/base.rb'
 require 'workpattern/clock'
-require 'workpattern/hour'
+require 'workpattern/constants'
 require 'workpattern/day'
 require 'workpattern/week'
 require 'workpattern/workpattern'
+require 'workpattern/week_pattern'
 
 #
 # workpattern.rb - date calculation library that takes into account patterns of
-# working and resting time and is aimed at supporting scheduling applications such 
-# as critical path analysis.
+# working and resting time and is aimed at supporting scheduling applications
+# such as critical path analysis.
 #
 # Author:        Barrie Callender 2011
 #
 # Documentation: Barrie Callender <barrie@callenb.org>
 #
 module Workpattern
-  
-  # Represents a full working hour
-  # @since 0.2.0
-  WORKING_HOUR = 2**60-1
-  
-  # Represents a full resting hour
-  # @since 0.2.0  
-  RESTING_HOUR = 0
-  
-  # The default workpattern name
-  # @since 0.2.0  
-  DEFAULT_WORKPATTERN_NAME = 'default'
-  
-  # The default base year
-  # @since 0.2.0
-  DEFAULT_BASE_YEAR = 2000
-  
-  # The default span in years
-  # @since 0.2.0
-  DEFAULT_SPAN = 100
-  
-  # Hour in terms of days
-  # @since 0.2.0
-  HOUR = Rational(1,24)
-  
-  # Minute in terms of days
-  # @since 0.2.0
-  MINUTE = Rational(1,1440)
-  
-  # Earliest or first time in the day
-  # @since 0.0.1
-  FIRST_TIME_IN_DAY=Clock.new(0,0)
-  
-  # Latest or last time in the day
-  # @since 0.0.1
-  LAST_TIME_IN_DAY=Clock.new(23,59)
-  
-  # Specifies a working pattern
-  # @since 0.0.1
-  WORK = 1
-  
-  # Specifies a resting pattern
-  # @since 0.0.1
-  REST = 0
-  
-  # Represents the days of the week to be used in applying working and resting patterns.
-  # Values exist for each day of the week as well as for the weekend (Saturday and Sunday), 
-  # the week (Monday to Friday) and all days in the week.
-  #
-  # @since 0.0.1
-  DAYNAMES={:sun => [0],:mon => [1], :tue => [2], :wed => [3], :thu => [4], :fri => [5], :sat => [6],
-              :weekday => [1,2,3,4,5],
-              :weekend => [0,6],
-              :all => [0,1,2,3,4,5,6]}
-              
-  # Covenience method to obtain a new <tt>Workpattern</tt> 
+
+  # Covenience method to obtain a new <tt>Workpattern</tt>
   #
   # A negative <tt>span</tt> counts back from the <tt>base</tt> year
   #
   # @param [String] name Every workpattern has a unique name.
   # @param [Integer] base Workpattern starts on the 1st January of this year.
-  # @param [Integer] span Workpattern spans this number of years ending on 31st December.
+  # @param [Integer] number of years ending on 31st December.
   # @return [Workpattern]
+  # @raise [NameError] creating a Workpattern with a name that already exists
   #
-  # @since 0.2.0
-  #
-  def self.new(name=DEFAULT_WORKPATTERN_NAME, base=DEFAULT_BASE_YEAR, span=DEFAULT_SPAN)
-    return Workpattern.new(name, base,span)
+  def self.new(name = DEFAULT_WORKPATTERN_NAME,
+               base = DEFAULT_BASE_YEAR,
+               span = DEFAULT_SPAN)
+    Workpattern.new(name, base, span)
   end
-  
-  # Covenience method to obtain an Array of all the known <tt>Workpattern</tt> objects
+
+  # Covenience method to obtain an Array of all the known <tt>Workpattern</tt>
+  # objects
   #
   # @return [Array] all <tt>Workpattern</tt> objects
   #
-  # @since 0.2.0
-  #
-  def self.to_a()
-    return Workpattern.to_a
+  def self.to_a
+    Workpattern.to_a
   end
 
-  # Covenience method to obtain an existing <tt>Workpattern</tt> 
+  # Covenience method to obtain an existing <tt>Workpattern</tt>
   #
   # @param [String] name The name of the Workpattern to retrieve.
   # @return [Workpattern]
   #
-  # @since 0.2.0
-  #
   def self.get(name)
-    return Workpattern.get(name)
+    Workpattern.get(name)
   end
-  
+
   # Convenience method to delete the named <tt>Workpattern</tt>
   #
   # @param [String] name The name of the Workpattern to be deleted.
   #
-  # @since 0.2.0
-  #
   def self.delete(name)
     Workpattern.delete(name)
   end
-   
+
   # Convenience method to delete all Workpatterns.
-  # 
-  # @since 0.2.0
   #
   def self.clear
     Workpattern.clear
   end
-  
-  # Convenience method to create a Clock object.  This can be used for specifying times 
-  # if you don't want to create a <tt>DateTime</tt> object
-  # 
+
+  # Convenience method to create a Clock object.  This can be used for
+  # specifying times if you don't want to create a <tt>DateTime</tt> object
+  #
   # @param [Integer] hour the number of hours.
   # @param [Integer] min the number of minutes
   # @return [Clock]
   # @see Clock
   #
-  # @since 0.2.0
-  #
-  def self.clock(hour,min)
-    return Clock.new(hour,min)
+  def self.clock(hour, min)
+    Clock.new(hour, min)
   end
+
 end

data/lib/workpattern/clock.rb

@@ -7,7 +7,7 @@ module Workpattern
   #   myClock.hour #=> 3
   #   myClock.min  #=> 32
   #   myClock.time #=> Time.new(1963,6,10,3,32)
-  #   myClock.to_s #=> 3:32 212 
+  #   myClock.to_s #=> 3:32 212
   #
   #   aClock=Clock.new(27,80)
   #   aClock.minutes #=> 1700
@@ -19,60 +19,61 @@ module Workpattern
   # @since 0.2.0
   #
   class Clock
-    
-    # Initialises an instance of <tt>Clock</tt> using the hours and minutes supplied
-    # or 0 if they are absent.  Although there are 24 hours in a day
+    # Initialises an instance of <tt>Clock</tt> using the hours and minutes
+    # supplied or 0 if they are absent.  Although there are 24 hours in a day
     # (0-23) and 60 minutes in an hour (0-59), <tt>Clock</tt> calculates
     # the full hours and remaining minutes of whatever is supplied.
     #
     # @param [Integer] hour number of hours
     # @param [Integer] min number of minutes
     #
-    def initialize(hour=0,min=0)
-      @hour=hour
-      @min=min
-      total_minutes = minutes
-      @hour=total_minutes.div(60)
-      @min=total_minutes % 60
+    def initialize(hour = 0, min = 0)
+      @hour = total_minutes(hour, min).div(60)
+      @min = total_minutes(hour, min) % 60
     end
-    
+
     # Returns the total number of minutes
     #
     # @return [Integer] total minutes represented by the Clock object
     #
     def minutes
-      return (@hour*60)+@min
+      total_minutes(@hour, @min)
     end
-    
+
     # Returns the hour of the clock (0-23)
     #
     # @return [Integer] hour of Clock from 0 to 23.
     #
     def hour
-      return @hour % 24
+      @hour % 24
     end
-    
+
     # Returns the minute of the clock (0-59)
     #
     # @return [Integer] minute of Clock from 0 to 59
     #
     def min
-      return @min % 60
+      @min % 60
     end
-    
+
     # Returns a <tt>Time</tt> object with the correct
     # <tt>hour</tt> and <tt>min</tt> values.  The date
     # is 10th June 1963.
     #
     # @return [DateTime] The time using the date of 10th June 1963 (My Birthday)
     def time
-      return DateTime.new(1963,6,10,hour,min)
+      DateTime.new(1963, 6, 10, hour, min)
     end
-    
 
     # @return [String] representation of <tt>Clock</tt> value as 'hh:mn minutes'
-    def to_s      
+    def to_s
       hour.to_s.concat(':').concat(min.to_s).concat(' ').concat(minutes.to_s)
     end
+
+    private
+
+    def total_minutes(hours, mins)
+      (hours * 60) + mins
+    end
   end
 end

data/lib/workpattern/constants.rb

@@ -0,0 +1,72 @@
+module Workpattern
+
+  # default name of a new Workpattern
+  DEFAULT_WORKPATTERN_NAME = 'default'.freeze
+  
+  # default base year for a new workpattern
+  DEFAULT_BASE_YEAR = 2000
+
+  # default span of years for a new Workpattern
+  DEFAULT_SPAN = 100
+
+  # 60 seconds in a minute
+  MINUTE = 60
+
+  # 60 minutes in an hour
+  HOUR = MINUTE * 60
+
+  # 24 hours in a day
+  HOURS_IN_DAY = 24
+
+  # Seconds in a day
+  DAY = HOUR * HOURS_IN_DAY
+
+  # 60 minutes in a working hour as binary bit per minute
+  WORKING_HOUR = 2**MINUTE - 1
+
+  # 0 minutes in a working hour as binary bits per minute
+  RESTING_HOUR = 0
+
+  # Earliest or first time in the day
+  FIRST_TIME_IN_DAY = Clock.new(0, 0)
+
+  # Latest or last time in the day
+  LAST_TIME_IN_DAY = Clock.new(23, 59)
+
+  # Flags for calculations
+  PREVIOUS_DAY = -1
+  SAME_DAY = 0
+  NEXT_DAY = 1
+
+  # Specifies a working pattern
+  WORK_TYPE = 1
+
+  # Specifies a resting pattern
+  REST_TYPE = 0
+
+  # All the days of the week
+  SUNDAY=0
+  MONDAY=1
+  TUESDAY=2
+  WEDNESDAY=3
+  THURSDAY=4
+  FRIDAY=5
+  SATURDAY=6
+  
+  # first and last day of week
+  FIRST_DAY_OF_WEEK = SUNDAY
+  LAST_DAY_OF_WEEK = SATURDAY
+
+  # Represents the days of the week to be used in applying working
+  # and resting patterns.
+  # Values exist for each day of the week as well as for the weekend
+  # (Saturday and Sunday), 
+  # the week (Monday to Friday) and all days in the week.
+  #
+  daynames = { sun: [0], mon: [1], tue: [2], wed: [3],
+               thu: [4], fri: [5], sat: [6], 
+               weekday: [1, 2, 3, 4, 5], 
+               weekend: [0, 6], 
+               all: [0, 1, 2, 3, 4, 5, 6] }
+  DAYNAMES = daynames.freeze
+end

data/lib/workpattern/day.rb

@@ -1,324 +1,245 @@
 module Workpattern
   
-  # @author Barrie Callender
-  # @!attribute values
-  #   @return [Array] each hour of the day
-  # @!attribute hours
-  #   @return [Integer] number of hours in the day
-  # @!attribute first_hour
-  #   @return [Integer] first working hour in the day
-  # @!attribute first_min
-  #   @return [Integer] first working minute in first working hour in the day
-  # @!attribute last_hour
-  #   @return [Integer] last working hour in the day
-  # @!attribute last_min
-  #   @return [Integer] last working minute in last working hour in the day
-  # @!attribute total
-  #   @return [Integer] total number of minutes in the day
-  #  
-  # Represents the 24 hours of a day.
-  #
-  # @since 0.2.0
-  # @todo implement a day with different number of hours in it to support daylight saving
-  #
   class Day
-    include Workpattern::Utility
-    attr_accessor :values, :hours, :first_hour, :first_min, :last_hour, :last_min, :total
     
-    # The new <tt>Day</tt> object can be created as either working or resting.
-    #
-    # @param [Integer] type is working (1) or resting (0)
-    #
-    def initialize(type=1)
-      @hours=24
-      hour=WORKING_HOUR if type==1
-      hour=RESTING_HOUR if type==0
-      @values=Array.new(@hours) {|index| hour }
-
-      set_attributes
+    attr_accessor  :pattern, :hours_per_day, :first_working_minute, :last_working_minute
+
+    def initialize(hours_per_day = HOURS_IN_DAY, type = WORK_TYPE)
+      @hours_per_day = hours_per_day
+      @pattern = initial_day(type)
+      set_first_and_last_minutes
     end
-    
-    # Creates a duplicate of the current <tt>Day</tt> instance.
-    #
-    # @return [Day] 
-    #
-    def duplicate
-      duplicate_day = Day.new()
-      duplicate_values=Array.new(@values.size)
-      @values.each_index {|index|
-        duplicate_values[index]=@values[index]
-        }
-      duplicate_day.values=duplicate_values
-      duplicate_day.hours = @hours
-      duplicate_day.first_hour=@first_hour
-      duplicate_day.first_min=@first_min
-      duplicate_day.last_hour=@last_hour
-      duplicate_day.last_min=@last_min
-      duplicate_day.total = @total
-      duplicate_day.refresh
-      return duplicate_day
+
+    def set_resting(start_time, finish_time)
+      mask = resting_mask(start_time, finish_time)
+      @pattern = @pattern & mask
+      set_first_and_last_minutes
     end
-    
-    # Recalculates characteristics for this day
-    #
-    def refresh
-      set_attributes
+
+    def set_working(from_time, to_time)
+      @pattern = @pattern | working_mask(from_time, to_time)
+      set_first_and_last_minutes
     end
+
+    def working_minutes(from_time = FIRST_TIME_IN_DAY, to_time = LAST_TIME_IN_DAY)
+      section = @pattern & working_mask(from_time, to_time)
+      section.to_s(2).count('1') 
+    end
+
+    def working?(hour, minute)
+      mask = (2**((hour * 60) + minute))
+      result = mask & @pattern
+      mask == result
+    end
+   
+    def resting?(hour, minute)
+      !working?(hour,minute)
+    end
+
+    def calc(a_date, a_duration)
+      if a_duration == 0
+        return a_date, a_duration, SAME_DAY
+      else
+        return a_duration > 0 ? add(a_date, a_duration) : subtract(a_date, a_duration)
+      end
+    end  
     
-    # Sets all minutes in a date range to be working or resting.
-    #
-    # @param [(#hour,#min)] start_time is the start of the range to set
-    # @param [(#hour, #min)] finish_time is the finish of the range to be set
-    # @param [Integer] type is either working (1) or resting (0)
-    #
-    def workpattern(start_time,finish_time,type)
-    
-      if start_time.hour==finish_time.hour
-        @values[start_time.hour]=@values[start_time.hour].wp_workpattern(start_time.min,finish_time.min,type)
+    private
+
+    def add(a_date, a_duration)
+      minutes_left = working_minutes(a_date)
+      if a_duration > minutes_left
+        return [a_date, a_duration - minutes_left, NEXT_DAY]
+      elsif a_duration < minutes_left
+        return add_minutes(a_date, a_duration)
       else
-        test_hour=start_time.hour
-        @values[test_hour]=@values[test_hour].wp_workpattern(start_time.min,59,type)
-        
-        while ((test_hour+1)<finish_time.hour)
-          test_hour+=1
-          @values[test_hour]=@values[test_hour].wp_workpattern(0,59,type)     
+        if working?(LAST_TIME_IN_DAY.hour, LAST_TIME_IN_DAY.min)
+	        return [a_date, 0, NEXT_DAY]
+        else
+          return_date = Time.gm(a_date.year, a_date.month, a_date.day, @last_working_minute.hour, @last_working_minute.min) + 60
+	        return [ return_date, 0, SAME_DAY]
         end
-        
-        @values[finish_time.hour]=@values[finish_time.hour].wp_workpattern(0,finish_time.min,type)
-      end
-      set_attributes
+      end	
     end
-    
-    # Calculates the result of adding <tt>duration</tt> to
-    # <tt>time</tt>.  The <tt>duration</tt> can be negative in
-    # which case it subtracts from <tt>time</tt>.
-    #
-    # An addition where there are less working minutes left in 
-    # the day than are being added will result in the time 
-    # returned being 00:00 on the following day.
-    #
-    # A subtraction where there are less working minutes left in
-    # the day than are being added will result in the time 
-    # returned being the previous day with the <tt>midnight</tt> flag set to true.
-    #
-    # @param [DateTime] time when the calculation starts from
-    # @param [Integer] duration is the number of minutes to add or subtract if it is negative
-    # @param [Boolean] midnight is a flag used in subtraction to pretend the time is actually midnight
-    # @return [DateTime,Integer,Boolean] Calculated time along with any remaining duration and the midnight flag
-    # 
-    def calc(time,duration,midnight=false)
-    
-      if (duration<0)
-        return subtract(time,duration, midnight)  
-      elsif (duration>0)
-        return add(time,duration)                
+
+    def add_minutes(a_date, a_duration)
+      elapsed_date = a_date + (a_duration * 60) - 60
+
+      if working_minutes(a_date, elapsed_date) == a_duration
+        return [elapsed_date += 60, 0, SAME_DAY]
       else
-        return time,duration, false
+        begin
+          elapsed_date += 60
+        end while working_minutes(a_date, elapsed_date) != a_duration
+	      return [elapsed_date += 60, 0, SAME_DAY]
       end
-    
     end
-    
-    # Returns true if the given minute is working and false if it is resting
-    #
-    # @param [(#hour, #min)] start is the time in the day to inspect
-    # @return [Boolean] true if the time is working and false if it is resting
-    #
-    def working?(start)
-      return true if minutes(start.hour,start.min,start.hour,start.min)==1
-      return false
+
+    def subtract(a_date, a_duration)
+      minutes_left = working_minutes(FIRST_TIME_IN_DAY,a_date - 60)
+      abs_duration = a_duration.abs
+      if abs_duration > minutes_left
+        return [a_date, a_duration + minutes_left, PREVIOUS_DAY]
+      elsif abs_duration < minutes_left
+        return subtract_minutes(a_date, abs_duration)
+      else
+        return [Time.gm(a_date.year,a_date.month,a_date.day,@first_working_minute.hour,@first_working_minute.min), 0, SAME_DAY]
+      end	
     end
-    
-    # Returns the difference in working minutes between two times.
-    #
-    # @param [(#hour, #min)] start start time in the range
-    # @param [(#hour, #min)] finish finish time in the range
-    # @return [Integer] number of working minutes
-    #
-    def diff(start,finish)
-      start,finish=finish,start if ((start <=> finish))==1
-      # calculate to end of hour
-      #
-      if (start.jd==finish.jd) # same day
-        duration=minutes(start.hour,start.min,finish.hour, finish.min)
-        duration -=1 if working?(finish)
-        start=finish
+
+    def subtract_minutes(a_date, abs_duration)
+      elapsed_date = a_date - (abs_duration * 60)
+      if working_minutes(elapsed_date, a_date - 60) == abs_duration
+        return [elapsed_date, 0, SAME_DAY]
       else
-        duration=minutes(start.hour,start.min,23, 59)
-        start=start+((23-start.hour)*HOUR) +((60-start.min)*MINUTE)
+        a_date -= 60
+        begin
+          elapsed_date -= 60
+        end while working_minutes(elapsed_date, a_date) != abs_duration
+	      return [elapsed_date, 0, SAME_DAY]
       end
-      return duration, start
+    end
+
+    def working_day
+      2**((60 * @hours_per_day) +1) - 1
     end
     
-    # Returns the total number of minutes between two times.
-    #
-    # @param [Integer] start_hour first hour in range
-    # @param [Integer] start_min first minute of first hour in range
-    # @param [Integer] finish_hour last hour in range
-    # @param [Integer] finish_min last minute of last hour in range
-    # @return [Integer] minutes between supplied hours and minutes
-    #
-    # @todo can this method and #diff method be combined?
-    #
-    def minutes(start_hour,start_min,finish_hour,finish_min)
-      
-      if (start_hour > finish_hour) || ((finish_hour==start_hour) && (start_min > finish_min))
-        start_hour,start_min,finish_hour,finish_min=finish_hour,finish_min,start_hour,finish_min 
+    def initial_day(type = WORK_TYPE)
+
+      pattern = 2**((60 * @hours_per_day) + 1)
+
+      if type == WORK_TYPE
+        pattern = pattern - 1
       end
       
-      if (start_hour==finish_hour)     
-        retval=@values[start_hour].wp_minutes(start_min,finish_min)
-      else
-    
-        retval=@values[start_hour].wp_minutes(start_min,59)
-        while (start_hour+1<finish_hour)        
-          retval+=@values[start_hour+1].wp_total     
-          start_hour+=1
-        end
-        retval+=@values[finish_hour].wp_minutes(0,finish_min)
-      end
-        
-      return retval
+      pattern
     end
 
-    private
+    def working_mask(start_time, finish_time)
     
-    # Calculates the attributes that describe the day.  Called after changes.
-    #
-    def set_attributes
-      @first_hour=nil
-      @first_min=nil
-      @last_hour=nil
-      @last_min=nil
-      @total=0
-      0.upto(@hours-1) {|index|
-        @first_hour=index if ((@first_hour.nil?) && (@values[index].wp_total!=0))
-        @first_min=@values[index].wp_first if ((@first_min.nil?) && (!@values[index].wp_first.nil?))        
-        @last_hour=index if (@values[index].wp_total!=0)
-        @last_min=@values[index].wp_last if (@values[index].wp_total!=0)
-        @total+=@values[index].wp_total
-      }
+      start = minutes_in_time(start_time) 
+      finish = minutes_in_time(finish_time) 
+
+      mask = initial_day
+
+      mask = mask - ((2**start) - 1)
+      mask & ((2**(finish + 1)) -1)
     end
-    
-    # Returns the first working minute as a <tt>DateTime</tt> or <tt>oo:oo</tt>
-    # when there is no working minutes in the day.  Used by the <tt>#subtract</tt> method
-    #
-    # @param [DateTime] time day for which the first working time is sought.
-    # @return [DateTime] the first working time of the day
-    #
-    def first_working_minute(time)
-      if @first_hour.nil?
-        return time - (HOUR*time.hour) - (MINUTE*time.min)
-      else  
-        time = time - HOUR * (time.hour - @first_hour)
-        time = time - MINUTE * (time.min - @first_min )
-        return time
-      end  
+
+    def resting_mask(start_time, finish_time)
+
+      start = minutes_in_time(start_time)
+      finish_clock = Clock.new(finish_time.hour, finish_time.min + 1) 
+
+      mask = initial_day(REST_TYPE)
+      if minutes_in_time(finish_time) != LAST_TIME_IN_DAY.minutes
+        mask = mask | working_mask(finish_clock,LAST_TIME_IN_DAY)
+      end	
+      mask | ((2**start) - 1)
+    end 
+
+    def minutes_in_time(a_time)
+      (a_time.hour * 60) + a_time.min
     end
-    
-    # Handles the subtraction of a duration from a time in the day.
-    # 
-    # @param [DateTime] time when the subtraction starts from
-    # @param [Integer] duration is the number of minutes to subtract from the <tt>time</tt>
-    # @param [Boolean] midnight is a flag used in subtraction to pretend the time is actually midnight
-    # @return [DateTime,Integer,Boolean] Calculated time along with any remaining duration and the midnight flag
-    #
-    def subtract(time,duration,midnight=false)    
-      if (time.hour==0 && time.min==0)
-        if midnight      
-          duration+=minutes(23,59,23,59)
-          time=time+(HOUR*23)+(MINUTE*59)
-          return calc(time,duration)
+
+    def last_minute
+      if working?(LAST_TIME_IN_DAY.hour, LAST_TIME_IN_DAY.min)
+        return LAST_TIME_IN_DAY
+      end
+
+      top = minutes_in_time(LAST_TIME_IN_DAY)
+      bottom = minutes_in_time(FIRST_TIME_IN_DAY)
+      mark = top / 2
+
+      not_done = true
+      while not_done
+      
+        minutes = working_minutes(minutes_to_time(mark), minutes_to_time(top))
+
+        if minutes > 1
+	        bottom = mark
+	        mark = mark + ((top - bottom) / 2)
+
+        elsif minutes == 0
+          top = mark
+	        mark = mark - (( top - bottom) / 2)
+
+        elsif minutes == 1 && is_resting(mark)
+          bottom = mark
+	        mark = mark + ((top - bottom) / 2)
+
         else
-          return time.prev_day, duration,true  
+	        not_done = false
+        
         end
-      elsif (time.hour==@first_hour && time.min==@first_min)
-        time=time-(HOUR*@first_hour) - (MINUTE*@first_min)
-        return time.prev_day, duration, true  
-      elsif (time.min>0)
-        available_minutes=minutes(0,0,time.hour,time.min-1) 
-      else  
-        available_minutes=minutes(0,0,time.hour-1,59)
-      end  
-      if ((duration+available_minutes)<0) # not enough minutes in the day  
-        time = midnight_before(time.prev_day) 
-        duration = duration + available_minutes
-        return time, duration, true
-      elsif ((duration+available_minutes)==0)
-        duration=0
-        time=first_working_minute(time)  
-      else
-        minutes_this_hour=@values[time.hour].wp_minutes(0,time.min-1)
-        this_hour=time.hour
-        until (duration==0)
-          if (minutes_this_hour<duration.abs)     
-            duration+=minutes_this_hour
-            time = time - (MINUTE*time.min) - HOUR
-            this_hour-=1
-            minutes_this_hour=@values[this_hour].wp_total
-          else
-            next_hour=(time.min==0)
-            time,duration=@values[this_hour].wp_calc(time,duration, next_hour)
-          end
+
+        if mark == bottom #& last_mark != mark
+	        mark = mark + 1
+        end  
+
+        if mark == 1 && top == 1 
+          mark = 0
         end
-      end  
-      return time,duration, false
+
+      end
+      minutes_to_time(mark)
+
     end
-    
-    # Returns the result of adding <tt>duration</tt> to the given <tt>time</tt>
-    # When there are not enough minutes in the day it returns the date
-    # for the start of the following day.
-    #
-    # @param [DateTime] time when the calculation starts from
-    # @param [Integer] duration is the number of minutes to add
-    # @return [DateTime,Integer] Calculated time along with any remaining duration
-    #
-    def add(time,duration)
-      available_minutes=minutes(time.hour,time.min,@hours-1,59)   
-      if ((duration-available_minutes)>0) # not enough minutes left in the day      
-
-        result_date= time.next_day - (HOUR*time.hour) - (MINUTE*time.min)
-        duration = duration - available_minutes      
-      else
-        total=@values[time.hour].wp_minutes(time.min,59)
-        if (total==duration) # this hour satisfies              
-          result_date=time - (MINUTE*time.min) + (MINUTE*@values[time.hour].wp_last) + MINUTE                   
-          duration = 0
-        else  
-          result_date = time
-          until (duration==0)
-            if (total<duration)
-              duration-=total
-              result_date=result_date + HOUR - (MINUTE*result_date.min)
-            else
-              result_date,duration=@values[result_date.hour].wp_calc(result_date,duration)     
-            end
-            total=@values[result_date.hour].wp_total
-          end
+
+    def first_minute
+      if working?(FIRST_TIME_IN_DAY.hour, FIRST_TIME_IN_DAY.min)
+        return FIRST_TIME_IN_DAY
+      end
+
+      top = minutes_in_time(LAST_TIME_IN_DAY)
+      bottom = minutes_in_time(FIRST_TIME_IN_DAY)
+      mark = top / 2
+
+      not_done = true
+      while not_done
+      
+        minutes = working_minutes(minutes_to_time(bottom), minutes_to_time(mark))
+        if minutes > 1
+          top = mark
+	        mark = mark - ((top - bottom) / 2)
+        elsif minutes == 0
+          bottom = mark
+	        mark = mark + (( top - bottom) / 2)
+        elsif minutes == 1 && is_resting(mark)
+          top = mark
+          mark = mark - ((top - bottom) / 2)
+        else
+          not_done = false
+        end  
+        
+        if mark == 1 && top == 1
+          mark = 0
         end
-      end    
-      return result_date,duration, false
-    end
-    
-    # Returns the start of the next hour.
-    #
-    # The next hour could be the start of the following day.
-    #
-    # @param [DateTime] start is the <tt>DateTime</tt> for which the following hour is required.
-    # @return [DateTime] the start of the next hour following the <tt>DateTime</tt> supplied
-    #
-    def next_hour(start)
-      return start+HOUR-(start.min*MINUTE) 
-    end
-    
-    # Returns the number of working minutes left in the current hour
-    #
-    # @param [DateTime] start is the <tt>DateTime</tt> for which the remaining working minutes 
-    #                   in the hour are required
-    # @return [Integer] number of remaining working minutes
-    #
-    def minutes_left_in_hour(start)
-      return @values[start.hour].wp_diff(start.min,60)
+      end
+      
+      minutes_to_time(mark)
+    end  
+
+    def minutes_to_time(minutes)
+      Time.gm(1963,6,10,minutes / 60, minutes - (minutes / 60 * 60))
     end
-    
+
+    def is_resting(minutes)
+      a_time =(minutes_to_time(minutes))
+      resting?(a_time.hour, a_time.min)
+    end  
+
+    def set_first_and_last_minutes
+      if working_minutes == 0
+        @first_working_minute = nil
+        @last_working_minute = nil
+      else	
+	      @first_working_minute = first_minute
+	      @last_working_minute = last_minute
+      end	
+    end  
+
+
   end
+
 end