gthc 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ed762c975444452f1ac856022506cfbefca548709194affc52b8bf229346839
-  data.tar.gz: 989e1971a5d5a515b8554c3ad8021d428fb251ff478680c9c13857be45f98b33
+  metadata.gz: f4a4d5c17afbded52b98ab45a4790c0b40603c84bd4dfdda8b372a098d1350fa
+  data.tar.gz: d08051fe205d84b2619a56a42b3be1ca34e33dc7200d4d61e1e3d0c8c631999b
 SHA512:
-  metadata.gz: 524ac3eef73252d447f3eefdabe24b7927a4d2d2f68311dad2ad0a84879fb159ac46da360de653d64d219ad792b686dac48e74f8cd236580ae11be02cfa3f195
-  data.tar.gz: 93b2f74bfa3dc56a51ac61c81c394a23c2b06cbc4ba4a86ce39d9b4ccd1f3f501c15486fd8a6ae4122ff3c5372f92efff522c322181061f03dcdff3f0de124d1
+  metadata.gz: 70b7aebf6fda10145d3772ff72bd7aa11be6d2e97f4a59affb1ed1f1da43f161efcbd4fa835c5b4199361a8d4908f69061056fdedf869f7ba4602da58c744c85
+  data.tar.gz: f160ec0134082c62c56929558a6e2cd59c60d18106a389320bd4b422e43615aaa0c163293e7097f12e77e4d09392a53e74938f561d8296ce47c7d772aff46d3d

data/.gitignore

@@ -12,3 +12,5 @@
 
 # generated file from building gem
 *.gem
+
+*dconf*

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    gthc (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  gthc!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.0.2

data/README.md

@@ -1,8 +1,4 @@
-# Gthc
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/gthc`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+# GTHC
 
 ## Installation
 
@@ -40,4 +36,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Gthc project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/gthc/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the GTHC project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/gthc/blob/master/CODE_OF_CONDUCT.md).

data/lib/gthc.rb

@@ -2,6 +2,7 @@ require "gthc/version"
 require "gthc/olson"
 
 module GTHC
+  include Olson
   class Error < StandardError; end
   # Your code goes here...
 end

data/lib/gthc/olson.rb

@@ -0,0 +1,12 @@
+require "gthc/olson/algorithm"
+
+module GTHC
+  module Olson
+    extend Algorithm
+
+    def self.driver(peopleList, scheduleGrid)
+      # Algorithm
+      schedule(peopleList, scheduleGrid)  
+    end
+  end
+end

data/lib/gthc/olson/algorithm.rb

@@ -0,0 +1,148 @@
+require "gthc/olson/helpers"
+require "gthc/olson/weight"
+
+module Algorithm
+
+  include Helpers
+  extend Weight
+
+  # Central document for creating schedule.
+  def schedule(people, scheduleGrid)
+    scheduleLength = scheduleGrid[0].length
+
+    # Remove all availability slots that are already filled in the schedule.
+    slots, graveyard, people = removeFilledSlots(people, scheduleGrid)
+
+    # Remove all availability slots that are already filled in the schedule.
+    while slots.length > 0
+
+      # Weight Reset - set all weights to 1.
+      slots = Weight.weightReset(slots)
+
+      # Weight Balance - prioritize people with fewer scheduled shifts.
+      people, slots = Weight.weightBalance(people, slots)
+
+      # Weight Contiguous - prioritize people to stay in the tent more time at once.
+      slots, scheduleGrid, graveyard = Weight.weightContiguous(slots, scheduleGrid, graveyard)
+
+      # Weight Tough Time - prioritize time slots with few people available.
+      slots = Weight.weightToughTime(slots, scheduleLength)
+
+      # Sort by Weights
+      slots.sort_by { |a| -a.weight }
+
+      # Update people, spreadsheet, and remove slots.
+      people, slots, graveyard, scheduleGrid = Weight.weightPick(people, slots, graveyard, scheduleGrid)
+
+    end
+
+    return processData(people, scheduleGrid)
+
+  end
+
+
+  # Remove all availability slots that are already filled in the schedule.
+  def removeFilledSlots(people, scheduleGrid)
+
+    # Reset Slots Array.
+    slots = Array.new
+    # Set up graveyard (Rows that are completely scheduled will go here).
+    graveyard = Array.new(scheduleGrid[0].length, 0)
+    # Set up counterArray (Going to count how scheduled a row is).
+    counterArray = Array.new(scheduleGrid[0].length, 0)
+
+    # Count number of scheduled tenters during a specific time.
+    scheduleGrid.each do | currentPerson |
+      counter = 0
+      while counter < currentPerson.length
+        if currentPerson[counter].status == "Scheduled"
+          counterArray[counter] = counterArray[counter] + 1
+        end
+        counter = counter + 1
+      end
+    end
+
+    # Iterate through every slot.
+    i = 0
+    while i < scheduleGrid.length
+
+      currentPerson = scheduleGrid[i]
+      counter = 0
+
+      while counter < scheduleGrid[i].length
+
+        # Determine how many people are needed.
+        isNight = currentPerson[counter].isNight
+        phase = currentPerson[counter].phase
+        peopleNeeded = Helpers.calculatePeopleNeeded(isNight, phase)
+        numPeople = counterArray[counter]
+
+        # Only add in slot if necessary.
+        if numPeople < peopleNeeded && currentPerson[counter].status == "Available"
+          slots.push(currentPerson[counter])
+        end
+
+        # Update graveyard
+        if numPeople >= peopleNeeded
+          graveyard[counter] = 1
+        end
+
+        # Update person freedom
+        # if numPeople >= peopleNeeded  && currentPerson[counter].status == "Available"
+        #   if isNight
+        #     people[i].nightFree -= 1
+        #   else
+        #     people[i].dayFree -= 1
+        #   end
+        # end
+
+        counter = counter + 1
+
+      end
+
+      i = i + 1
+
+    end
+
+    return slots, graveyard, people
+
+  end
+
+  def processData(people, scheduleGrid)
+    # compress data from 2d grid with a single-deminsion of
+    # all of the scheduled slots
+    combinedGrid = []
+
+    # iterating through every unique slot, and
+    # checking for any people that are scheduled on that slot as well
+    for slotIndex in 0...scheduleGrid[0].length
+      slotData = scheduleGrid[0][slotIndex].to_hash
+      slot = {
+        "startDate": slotData["startDate"],
+        "endDate": slotData["endDate"],
+        "isNight": slotData["isNight"],
+        "phase": slotData["phase"],
+      }
+      slot[:ids] = Array.new
+
+      # checking every person at that slot for status
+      for personIndex in 0...people.length
+        person = people[personIndex]
+        if scheduleGrid[personIndex][slotIndex].status == "Scheduled"
+          slot[:ids].push(person.id)
+        end
+      end
+
+      combinedGrid.push(slot)
+    end
+
+    # prints amount of people needed in a slot based on time and phase
+    combinedGrid.each do | slot |
+      peopleNeeded = Helpers.calculatePeopleNeeded slot[:isNight], slot[:phase]
+      peopleLeft = peopleNeeded - slot[:ids].length
+      slot["peopleLeft"] = peopleLeft
+    end
+
+    combinedGrid
+  end
+end

data/lib/gthc/olson/helpers.rb

@@ -0,0 +1,26 @@
+module Helpers
+  def self.calculatePeopleNeeded(nightBoolean, phase)
+    if phase == "Black"
+      if nightBoolean
+        return 10
+      else
+        return 2
+      end
+    end
+    if phase == "Blue"
+      if nightBoolean
+        return 6
+      else
+        return 1
+      end
+    end
+    if phase == "White"
+      if nightBoolean
+        return 2
+      else
+        return 1
+      end
+    end
+  end
+
+end

data/lib/gthc/olson/weight.rb

@@ -0,0 +1,235 @@
+require "gthc/olson/helpers"
+
+module Weight
+  include Helpers
+
+  # Weight Reset - set all weights to 1.
+  def self.weightReset(slots)
+    slots.each do | currentSlot |
+      currentSlot.weight = 1;
+    end
+    slots
+  end
+
+  # Weight Balance - prioritize people with fewer scheduled shifts
+  def self.weightBalance(people, slots)
+
+    slots.each do | currentSlot |
+
+      # Establish variables.
+      currentPersonID = currentSlot.personID
+      dayScheduled = people[currentPersonID].dayScheduled
+      nightScheduled = people[currentPersonID].nightScheduled
+      night = currentSlot.isNight;
+
+      nightMulti = 0;
+      dayMulti = 0;
+
+      # Set multipliers.
+      if nightScheduled != 0
+        nightMulti = 1.0 / nightScheduled
+      else
+        nightMulti = 1.5
+      end
+
+      if dayScheduled != 0
+        dayMulti = (1.0/(dayScheduled+nightScheduled*4*2))
+      else
+        dayMulti = 1.5
+      end
+
+      #Adjust weights with multipliers.
+      if night
+        currentSlot.weight = currentSlot.weight * nightMulti
+      else
+        currentSlot.weight = currentSlot.weight * dayMulti
+      end
+
+    end
+    return people, slots
+  end
+
+  def self.gridLimits(row, rowLength)
+    return row - 1 < 0,
+           row + 1 > rowLength - 1
+  end
+
+  # Weight Contiguous - prioritize people to stay in the tent more time at once.
+  def self.weightContiguous(slots, scheduleGrid, graveyard)
+
+    i = 0
+    while i < slots.length
+      # Establish Variables
+      currentRow = slots[i].row
+      currentCol = slots[i].col
+
+      aboveRow = currentRow-1
+      belowRow = currentRow+1
+
+      # grab all slots under the same col as the inspected slot in order
+      # to get the slots above and below
+      allSlots = scheduleGrid[currentCol]
+      slotsLength = allSlots.length
+
+      # find what to skip
+      skipAboveRow, skipBelowRow = gridLimits(currentRow, slotsLength)
+
+      currentIsNight = slots[i].isNight
+      aboveIsNight = !skipAboveRow && allSlots[aboveRow].isNight
+      belowIsNight = !skipBelowRow && allSlots[belowRow].isNight
+
+      aboveTent = !skipAboveRow && allSlots[aboveRow].status == "Scheduled"
+      belowTent = !skipBelowRow && allSlots[belowRow].status == "Scheduled"
+      aboveSome = !skipAboveRow && allSlots[aboveRow].status == "Somewhat"
+      belowSome = !skipBelowRow && allSlots[belowRow].status == "Somewhat"
+      aboveFree = !skipAboveRow && allSlots[aboveRow].status == "Available"
+      belowFree = !skipBelowRow && allSlots[belowRow].status == "Available"
+
+      multi = 1
+
+      # Both are scheduled.
+      if aboveTent && belowTent
+        multi = 100
+      end
+
+      # Both are not free
+      if !belowTent && !belowFree && !aboveSome && !belowSome && !aboveTent && !aboveFree
+        if slots[i].weight > 0
+          multi = -1
+        end
+      end
+
+      # Above is scheduled, below is free.
+      if aboveTent && !belowTent && belowFree
+        multi = 3.25
+      end
+
+      # Below is scheduled, above is free.
+      if belowTent && !aboveTent && aboveFree
+        multi = 3.25
+      end
+
+      # Above is scheduled, below is not free.
+      if aboveTent && !belowTent && !belowFree
+        multi = 3
+      end
+
+      # Below is scheduled, above is not free.
+      if belowTent && !aboveTent && !aboveFree
+        multi = 3
+      end
+
+      # Both are free
+      if belowFree && aboveFree
+        multi = 2.75
+      end
+
+      # Above is free, below is not free
+      if aboveFree && !belowTent && !belowFree
+        multi = 1
+      end
+
+      # Below is free, above is not free
+      if(belowFree && !aboveTent && !aboveFree)
+        multi = 1
+      end
+
+      # Night Multi
+      if aboveIsNight || belowIsNight || currentIsNight
+        multi *= 1.25
+      end
+
+      # Occurance of Somewhat Available
+      if aboveSome || belowSome
+        multi *= 0.5
+      end
+
+      slots[i].weight = slots[i].weight*multi
+      i += 1
+
+    end
+
+    return slots, scheduleGrid, graveyard
+  end
+
+  # Weight Tough Time - prioritize time slots with few people available. */
+  def self.weightToughTime(slots, scheduleLength)
+
+    # Set up counterArray (Rows that are filled).
+    counterArray = Array.new(scheduleLength + 1, 0)
+
+    # Fill counterArray.
+    slots.each do | currentSlot |
+      currentRow = currentSlot.row
+      counterArray[currentRow] = counterArray[currentRow] + 1
+    end
+
+    # Update Weights.
+    slots.each do | currentSlot |
+      currentRow = currentSlot.row
+      currentPhase = currentSlot.phase
+      nightBoolean = currentSlot.isNight
+      peopleNeeded = Helpers.calculatePeopleNeeded(nightBoolean, currentPhase)
+      numFreePeople = counterArray[currentRow]
+      currentSlot.weight = currentSlot.weight*(12/numFreePeople)*peopleNeeded
+    end
+
+    return slots
+  end
+
+  # Update people, spreadsheet, and remove slots.
+  def self.weightPick(people, slots, graveyard, scheduleGrid)
+
+    # Remove winner from list.
+    winner = slots.shift;
+
+    # Update person information.
+    currentPersonID = winner.personID;
+    currentTime = winner.isNight;
+
+    if currentTime
+      people[currentPersonID].nightScheduled += 1
+      people[currentPersonID].nightFree -= 1
+     else
+      people[currentPersonID].dayScheduled += 1
+      people[currentPersonID].dayFree -= 1
+    end
+
+    # Establish Variables
+    currentRow = winner.row
+    currentCol = winner.col
+    tentCounter = 0
+
+    # Update Data
+    scheduleGrid[currentCol][currentRow].status = "Scheduled";
+
+    # Count number of scheduled tenters during winner slot.
+    i = 0
+    while i < scheduleGrid.length
+      if scheduleGrid[i][currentRow].status == "Scheduled"
+        tentCounter = tentCounter + 1
+      end
+      i += 1
+    end
+
+    # Determine how many people are needed.
+    peopleNeeded = Helpers.calculatePeopleNeeded(currentTime, winner.phase)
+
+    # Update Slots and Graveyard
+    if tentCounter >= peopleNeeded
+      graveyard[currentRow] = 1
+      j = 0
+      tempSlots = []
+      while j < slots.length
+        tempRow = slots[j].row
+        if tempRow != currentRow
+          tempSlots.push slots[j]
+        end
+        j += 1
+      end
+      slots = tempSlots
+    end
+
+    return people, slots, graveyard, scheduleGrid
+  end
+end

data/lib/gthc/version.rb

@@ -1,3 +1,3 @@
 module GTHC
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gthc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Aman Ibrahim
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-21 00:00:00.000000000 Z
+date: 2019-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,7 @@ files:
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -73,6 +74,10 @@ files:
 - bin/setup
 - gthc.gemspec
 - lib/gthc.rb
+- lib/gthc/olson.rb
+- lib/gthc/olson/algorithm.rb
+- lib/gthc/olson/helpers.rb
+- lib/gthc/olson/weight.rb
 - lib/gthc/version.rb
 homepage: https://www.gthc.io/
 licenses:
@@ -95,7 +100,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: GTHC Ruby Gem