Add Dijkstra algorithm

Author: AdrianSmith

lib/cpm_solver/solvers/dijkstra.rb

@@ -1,12 +1,90 @@
 module CpmSolver
   module Solvers
     class Dijkstra < Solver
+      INF = Float::INFINITY
+
+      protected
+
       def calculate_early_times
-        raise NotImplementedError, "#{self.class} must implement #calculate_early_times"
+        # Initialize distances
+        distances = {}
+        program.activities.each_value do |activity|
+          distances[activity.reference] = -INF
+        end
+
+        # Find start activities (those with no predecessors)
+        start_activities = program.activities.values.select { |a| a.predecessors.empty? }
+        start_activities.each { |activity| distances[activity.reference] = 0 }
+
+        # Process activities in order of increasing distance
+        queue = start_activities.dup
+        while queue.any?
+          current = queue.min_by { |a| distances[a.reference] }
+          queue.delete(current)
+
+          # Update distances to successors
+          current.successors.each do |succ_ref|
+            successor = program.activities[succ_ref]
+            new_distance = distances[current.reference] + current.duration
+
+            if new_distance > distances[successor.reference]
+              distances[successor.reference] = new_distance
+              queue << successor unless queue.include?(successor)
+            end
+          end
+        end
+
+        # Set early times for all activities
+        program.activities.each_value do |activity|
+          activity.early_start = distances[activity.reference]
+          activity.early_finish = activity.early_start + activity.duration
+        end
       end
 
       def calculate_late_times
-        raise NotImplementedError, "#{self.class} must implement #calculate_late_times"
+        return unless program.activities.values.all? { |a| a.early_finish }
+
+        project_end = program.activities.values.map(&:early_finish).max
+        distances = {}
+        program.activities.each_value do |activity|
+          distances[activity.reference] = INF
+        end
+
+        # Find end activities (those with no successors)
+        end_activities = program.activities.values.select { |a| a.successors.empty? }
+        end_activities.each do |activity|
+          # Set late finish to project end time
+          distances[activity.reference] = project_end
+        end
+
+        # Process activities in reverse order
+        queue = end_activities.dup
+        processed = Set.new
+
+        while queue.any?
+          current = queue.min_by { |a| -distances[a.reference] }
+          queue.delete(current)
+          processed.add(current)
+
+          # Update distances to predecessors
+          current.predecessors.each do |pred_ref|
+            predecessor = program.activities[pred_ref]
+            new_distance = distances[current.reference] - current.duration
+
+            if new_distance < distances[predecessor.reference]
+              distances[predecessor.reference] = new_distance
+              unless processed.include?(predecessor)
+                queue << predecessor unless queue.include?(predecessor)
+              end
+            end
+          end
+        end
+
+        # Set late times for all activities
+        program.activities.each_value do |activity|
+          activity.late_finish = distances[activity.reference]
+          activity.late_start = activity.late_finish - activity.duration
+        end
       end
     end
   end

spec/cpm_solver/integration/house_program_spec.rb

@@ -138,6 +138,10 @@ def log(message)
     include_examples "solver behavior", CpmSolver::Solvers::Topological
   end
 
+  context "with Dijkstra solver" do
+    include_examples "solver behavior", CpmSolver::Solvers::Dijkstra
+  end
+
   after(:all) do
     if @verbose
       if Dir.exist?(@tmp_dir)

spec/cpm_solver/performance/solver_performance_spec.rb

@@ -147,13 +147,15 @@ def generate_large_program
       results = {
         'Bellman-Ford' => [],
         'Floyd-Warshall' => [],
-        'Topological' => []
+        'Topological' => [],
+        'Dijkstra' => []
       }
 
       solvers = {
         'Bellman-Ford' => CpmSolver::Solvers::BellmanFord,
         'Floyd-Warshall' => CpmSolver::Solvers::FloydWarshall,
-        'Topological' => CpmSolver::Solvers::Topological
+        'Topological' => CpmSolver::Solvers::Topological,
+        'Dijkstra' => CpmSolver::Solvers::Dijkstra
       }
 
       # Run each solver multiple times

spec/cpm_solver/solvers/dijkstra_spec.rb

@@ -1,22 +1,95 @@
 require "spec_helper"
 
 RSpec.describe CpmSolver::Solvers::Dijkstra do
-  let(:program) { instance_double(CpmSolver::Core::Program) }
+  let(:program) { CpmSolver::Core::Program.new("Test Program") }
+  let(:solver) { described_class.new(program) }
+  let(:activity_a) { CpmSolver::Core::Activity.new("A", "Task A", 5) }
+  let(:activity_b) { CpmSolver::Core::Activity.new("B", "Task B", 3) }
+  let(:activity_c) { CpmSolver::Core::Activity.new("C", "Task C", 4) }
 
-  describe '#solve' do
-    subject(:solver) { described_class.new(program) }
+  before do
+    program.add_activity(activity_a)
+    program.add_activity(activity_b)
+    program.add_activity(activity_c)
+    program.add_predecessors(activity_b, [activity_a])
+    program.add_predecessors(activity_c, [activity_b])
+  end
+
+  describe "#calculate_early_times" do
+    before { solver.send(:calculate_early_times) }
+
+    it "calculates early start times" do
+      expect(activity_a.early_start).to eq(0)
+      expect(activity_b.early_start).to eq(5)
+      expect(activity_c.early_start).to eq(8)
+    end
+
+    it "calculates early finish times" do
+      expect(activity_a.early_finish).to eq(5)
+      expect(activity_b.early_finish).to eq(8)
+      expect(activity_c.early_finish).to eq(12)
+    end
+  end
+
+  describe "#calculate_late_times" do
+    before do
+      solver.send(:calculate_early_times)
+      solver.send(:calculate_late_times)
+    end
+
+    it "calculates late start times" do
+      expect(activity_a.late_start).to eq(0)
+      expect(activity_b.late_start).to eq(5)
+      expect(activity_c.late_start).to eq(8)
+    end
+
+    it "calculates late finish times" do
+      expect(activity_a.late_finish).to eq(5)
+      expect(activity_b.late_finish).to eq(8)
+      expect(activity_c.late_finish).to eq(12)
+    end
+  end
+
+  describe "#solve" do
+    before { solver.solve }
+
+    it "calculates slack times" do
+      expect(activity_a.slack).to eq(0)
+      expect(activity_b.slack).to eq(0)
+      expect(activity_c.slack).to eq(0)
+    end
+
+    it "identifies critical path" do
+      expect(activity_a.critical).to be true
+      expect(activity_b.critical).to be true
+      expect(activity_c.critical).to be true
+    end
+  end
+
+  context "with parallel paths" do
+    let(:activity_d) { CpmSolver::Core::Activity.new("D", "Task D", 2) }
+    let(:activity_e) { CpmSolver::Core::Activity.new("E", "Task E", 3) }
 
     before do
-      allow(program).to receive(:validate)
-      allow(program).to receive(:status).and_return(CpmSolver::Core::Program::STATUS[:validated])
-      allow(program).to receive(:activities).and_return({})
+      program.add_activity(activity_d)
+      program.add_activity(activity_e)
+      program.add_predecessors(activity_d, [activity_a])
+      program.add_predecessors(activity_e, [activity_d])
+      program.add_predecessors(activity_c, [activity_b, activity_e])
     end
 
-    it 'raises NotImplementedError when calculating early times' do
-      expect { solver.solve }.to raise_error(
-        NotImplementedError,
-        "CpmSolver::Solvers::Dijkstra must implement #calculate_early_times"
-      )
+    it "calculates correct early and late times for parallel paths" do
+      solver.solve
+
+      expect(activity_a.early_start).to eq(0)
+      expect(activity_b.early_start).to eq(5)
+      expect(activity_d.early_start).to eq(5)
+      expect(activity_e.early_start).to eq(7)
+      expect(activity_c.early_start).to eq(10)
+
+      expect(activity_d.critical).to be true
+      expect(activity_e.critical).to be true
+      expect(activity_b.slack).to be > 0
     end
   end
 end

spec/spec_helper.rb

@@ -2,6 +2,7 @@
 require "cpm_solver/solvers/bellman_ford"
 require "cpm_solver/solvers/floyd_warshall"
 require "cpm_solver/solvers/topological"
+require "cpm_solver/solvers/dijkstra"
 require "pry"
 
 RSpec.configure do |config|