schedsolver2 0.0.1

data/features/step_definitions/heuristic_steps.rb

@@ -0,0 +1,49 @@
+Given /^the school's (\d+)th ET works MWF$/ do |arg1|
+  @school.print :consts
+  @school.print :teachers
+  et = @school.ts[:e][0]
+  @et_id = et.id
+  et.work_days = [:mon, :wed, :fri]
+end
+
+Given /^each HT must have (\d+) ECs\/wk$/ do |arg1|
+  @school.cs[:ecs_per_week] = arg1.to_i
+end
+
+Given /^each HT may have at most (\d+) ECs\/dy$/ do |arg1| 
+  @school.cs[:max_ecs_per_day] = arg1.to_i
+end
+
+When /^the schedule is generated$/ do 
+  @school.add :schedules, 1
+  @school.print :consts
+  @school.generate_schedule(0)
+  @school.print :schedules
+end
+
+Then /^there wil be one EC on each of MWF for ET (\d+)$/ do |arg1|  
+  @school.ht_ids.each do |ht_id|
+    week_count = 0
+    [:mon, :wed, :fri].each do |day|
+      day_count = 0
+      @school.times.each do |time|
+        if @school.scheds[0][day, time, @et_id] == ht_id then day_count += 1 end
+      end
+      day_count.should be <= @school.cs[:max_ecs_per_day]
+      week_count += day_count
+    end
+    week_count.should == @school.cs[:ecs_per_week] 
+  end
+end
+
+Then /^there will be three total ET (\d+) entries$/ do |arg1| 
+  count = 0
+  @school.days.each do |day|
+    @school.times.each do |time|
+      if @school.scheds[0][day, time, @et_id+1] == @school.ht_ids[0]
+        count += 1
+      end
+    end
+  end
+  count.should == 3
+end

data/features/step_definitions/shared_steps.rb

@@ -0,0 +1,10 @@
+Given /^I have an initialized School$/ do
+  @school = Schedsolver2::School.new @si, @ts, @cs
+  @school.log = Logger.new( File.expand_path("../../../log/logfile.log",__FILE__))
+  @school.log.error("\n"*15 + "BEGINNING CUCUMBER ACCEPTANCE TEST RUN OF SS2")
+end
+
+Given /^It has "(.*?)" schedule(s?)$/ do |arg1, arg2|
+  x = arg1.to_i
+  @school.add :schedules, x
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH << File.expand_path('~/schedsolver2/lib', __FILE__)
+require 'cucumber/rspec/doubles'
+require 'schedsolver2'
+

data/features/support/shared_contexts.rb

@@ -0,0 +1,47 @@
+Before('~@big_example') do
+  @si = {:start_time => 8,
+         :end_time   => 15,
+         :num_blocks => 7,
+         :block_size => 1}
+
+  ets, et_ns = [], [:Art, :Music]
+  et_ns.each do |name|
+    ets << Schedsolver2::Teacher.new(name)
+  end
+  hts, ht_ns = [], [:One]
+  ht_ns.each do |name|
+    hts << Schedsolver2::Teacher.new(name)
+  end
+  @ts = {:e => ets,
+        :h => hts}
+  @cs = {:h => [],
+        :s => []}
+@school2 = Schedsolver2::School.new @si, @ts, @cs
+@all_days_slot_descriptor = {}
+  @school2.days.each do |day|
+    @all_days_slot_descriptor[day] ||= {} 
+    @school2.times.each do |time|
+      @all_days_slot_descriptor[day][time] = @school2.et_ids
+    end
+  end
+end
+
+Before('@heuristic') do
+  @si = {:start_time => 8,
+         :end_time   => 15,
+         :num_blocks => 7,
+         :block_size => 1}
+
+  @ets = [ Schedsolver2::Teacher.new(:Art), Schedsolver2::Teacher.new(:Music) ]
+  @hts = [ Schedsolver2::Teacher.new(:One)]
+
+  @ts = {:e => @ets, :h => @hts}
+  @cs = {}
+
+  @school = Schedsolver2::School.new @si, @ts, @cs
+
+  @school.cs[:ecs_per_week] = 2
+  @school.cs[:max_ecs_per_day] = 2
+end
+
+

data/lib/schedsolver2.rb

@@ -0,0 +1,84 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'pp'
+require 'text-table'
+require 'logger'
+
+module Schedsolver2
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path('..', __FILE__) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  VERSION = "0.0.1"
+  # :startdoc:
+
+  #Setup the module-scoped log
+  #
+  def self.log
+    @log ||= Logger.new(STDOUT)
+  end
+
+  def self.log=(arg)
+    @log = arg
+  end
+
+  def log
+    Schedsolver2.log
+  end
+
+  def log=(arg)
+    Schedsolver2.log = arg
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+
+end  # module Schedsolver2
+
+Schedsolver2.require_all_libs_relative_to(__FILE__)

data/lib/schedsolver2/ClassCounter.rb

@@ -0,0 +1,42 @@
+module Schedsolver2
+
+  class ClassCounter
+    attr_reader :counts
+
+    def initialize et_ids
+      @counts = {}
+      [:mon, :tue, :wed, :thu, :fri].each do |day|
+        @counts[day] = Hash.new
+        et_ids.each do |et_id|
+          @counts[day][et_id] = 0
+        end
+      end
+    end
+
+    def [](arg1, arg2)
+      @counts[arg1][arg2]
+    end
+
+    def []=(arg1, arg2, val)
+      @counts[arg1][arg2] = val
+    end
+
+    def by_et_id id
+      count = 0
+      @counts.each_key do |day|
+        count += @counts[day][id] 
+      end
+      return count
+    end
+
+    def by_day day
+    count = 0
+    @counts[day].each_value { |v| count += v }
+    return count
+    end
+
+    def to_s
+      @counts.to_s
+    end
+  end
+end

data/lib/schedsolver2/constraint.rb

@@ -0,0 +1,133 @@
+module Schedsolver2
+
+  class Constraint
+    include Schedsolver2
+    attr_reader :descriptors, :test, :assess
+    @@days = [:mon, :tue, :wed, :thu, :fri]
+  
+    def initialize hsh
+      raise ArgumentError, "No type specified" unless hsh.has_key?(:type)
+      raise ArgumentError, "No slot descriptors given" unless hsh.has_key?(:s_ds)
+
+      if hsh.has_key?(:name) 
+        @name = hsh[:name] 
+      else 
+        @name = 'Unnamed constraint'
+      end
+
+      @descriptors = []
+      hsh[:s_ds].each do |s_d|
+        @descriptors << Constraint.make_slots_ary(s_d)
+      end
+
+      unless hsh[:type] == :custom
+        raise ArgumentError, "No et specified"  unless hsh.has_key?(:et_ids)
+        @test = get_test_for(hsh)
+        @assess = get_assess_for(hsh)
+      else
+        @test = hsh[:test]  
+        @assess = hsh[:assess]
+      end
+    end 
+
+    def to_s
+      @name
+    end
+
+    # # # # # # Class Methods # # # # # # # #   
+
+    # slot_descriptors are: hash[day][time][et_id] that specifiy groups
+    #   of slots that can be used when enforcing constraints.
+
+    # slot_arys are: an array like [ [day, time, et_id], ...] that is
+    #   actually used by the Proc of the constraint.
+
+    # In the constructor, we get one or more descriptors which are 
+    # converted into an array of slots_arys. Confusing variable names are
+    # everywhere. I suck.
+
+    def self.make_slots_ary s_d
+      raise ArgumentError, "No slots given in slot descriptor" if s_d == nil
+      ary = []
+      s_d.each do |day, hour_hash| 
+        hour_hash.each do |hour, et_ids| 
+          et_ids.each do |et_id| 
+            ary << [day, hour, et_id]
+          end
+        end
+      end
+      return ary
+    end
+
+    def self.day_descriptor day, times, et_ids
+      raise ArgumentError, "et_ids not an array" unless (et_ids.class == Array)
+      h = {}
+      h[day.to_sym] = {}
+      times.each do |time|
+        h[day.to_sym][time] = et_ids
+      end
+      return h
+    end
+    
+    def self.days_descriptor days, times, et_ids
+      s_d = {}
+      days.each do |day|
+        s_d.merge! Constraint.day_descriptor(day, times, et_ids)
+      end
+      return s_d
+    end
+
+    def self.week_descriptor times, et_ids
+      s_d = {} 
+      @@days.each do |day|
+        s_d.merge! Constraint.day_descriptor(day, times, et_ids)
+      end
+      return s_d
+    end
+
+    def get_test_for(hsh)
+      case hsh[:type]
+      when :part_time
+        raise ArgumentError, "et_ids.size > 1 for part_time type" unless(hsh[:et_ids].size <= 1)
+        p = Proc.new { |slot, value| if value != nil then true else false end}
+        return p
+      end
+    end
+
+    def get_assess_for(hsh)
+      case hsh[:type]
+      when :part_time
+        p = Proc.new {|count| if count > 0 then false else true end } 
+        return p
+      end
+    end
+        
+
+    def self.hard_assert schedule, constraint
+
+      unless schedule.class == Schedule 
+        raise ArgumentError, "Schedule is of wrong class #{schedule.class}" 
+      end
+
+      unless constraint.class == Constraint
+        raise ArgumentError, "Constraint is of wrong class #{constraint.class}" 
+      end
+
+      constraint.descriptors.each do |descriptor|
+        count = 0
+        descriptor.each do |slot|
+          d,t,id = slot 
+          value = schedule[d,t,id]
+          if (constraint.test.call(slot, value) == true)
+            count += 1 
+            #Schedsolver2.log.info("Constraint#hard_assert #{d},#{t},#{id} gives true value: #{value}")
+          else
+            #Schedsolver2.log.info("#Constraint#hard_assert #{d},#{t},#{id} gives false value: #{value}")
+          end
+        end
+        if constraint.assess.call(count) != true then return false end
+      end
+      return true
+    end
+  end
+end

data/lib/schedsolver2/schedule.rb

@@ -0,0 +1,107 @@
+module Schedsolver2
+  class Schedule
+    include Schedsolver2
+    attr_accessor :sched
+
+    def initialize consts    
+      @@consts = consts
+      @sched = init_sched
+    end
+
+    def init_sched
+      n_days = @@consts[:days].size  
+      n_ts = @@consts[:times].size  
+      n_ets = @@consts[:et_ids].size  
+      Array.new(n_days){ Array.new(n_ts){ Array.new(n_ets, nil)}}
+    end
+
+    def self.parse_getter_setter_args day, time, et_id
+      if day == nil 
+        raise ArgumentError, "Day is nil, cannot proceed"
+      end
+
+      i = @@consts[:days].index(day) 
+      j = @@consts[:times].index(time.to_f) 
+      k = @@consts[:et_ids].index(et_id) 
+
+      if (day != nil and i == nil) then raise ArgumentError, "day #{day} isn't is days" end
+      if (time != nil and j == nil) then raise ArgumentError, "time #{time} isn't is times" end
+      if (et_id != nil and k == nil) then raise ArgumentError, "et_id #{et_id} isn't is ed_ids" end
+
+      return [i,j,k]
+    end
+
+    def []=(day=nil, time=nil, et_id=nil, entry=nil)  
+      ijk = Schedule.parse_getter_setter_args(day, time, et_id)
+      i, j, k = ijk
+      
+      if j == nil 
+        @sched[i] = entry
+      elsif k == nil
+        @sched[i][j] = entry
+      else
+        sanity_check ijk, entry
+        @sched[i][j][k] = entry
+      end
+    end
+
+    def [](day=nil, time=nil, et_id=nil)
+      ijk = Schedule.parse_getter_setter_args(day, time, et_id)
+      i, j, k = ijk
+
+      if j == nil 
+        @sched[i]
+      elsif k == nil
+        @sched[i][j]
+      else
+        @sched[i][j][k]
+      end
+    end
+
+    def sanity_check ijk, entry
+      i, j, k = ijk 
+      #check for simultaneous ECs assigned to HC 
+      num_ets = @@consts[:et_ids].size
+      (0..num_ets-1).each do |n|
+        if n == k then next end
+        if @sched[i][j][n] == entry 
+          raise(InsanityError,"Can't assign HT #{entry} to sched[#{i}, #{j}, #{k}] because already assigned to sched[#{i}, #{j}, #{n}]")
+        end
+      end
+      # Check for simultaneous HCs assigned to EC?
+      # Should this be carried out by algorithm instead?
+    end
+
+
+    def to_s
+      head = [nil] + (@@consts[:et_ids] + [nil]) * 5
+      rows = []
+      #create col1
+      @@consts[:times].each { |t| rows << [t] }
+      #add body
+      @@consts[:days].each_index do |d| 
+        @@consts[:times].each_index do |t|
+          rows[t] += (@sched[d][t] << "^")
+        end
+      end
+      return Text::Table.new(:head => head, :rows => rows).to_s
+    end
+  end
+
+class InsanityError < StandardError
+end
+
+end
+
+#    def check_args *argv
+#      2.times do |i|
+#        if argv[i] == nil 
+#          return true
+#        unless (@@consts[:days].include?(argv[i]) || @@consts[:times].include?(argv[i])  || @@consts[:et_ids].include?(argv[i]))
+#          raise ArgumentError, "getter or setter had bad paramaters (not in @@consts)"
+#        else
+#        end
+#      end
+#    end
+#  end
+