Black Borders around AddCourses Component

.github/workflows/frontend.yml

@@ -8,10 +8,11 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     defaults:
       run:
         working-directory: ./frontend
+
     name: Build and lint
     steps:
       - name: Checkout repository

.gitignore

@@ -23,3 +23,4 @@ node_modules/
 # Environment variables
 .env
 .env.*
+

algorithm-prototyping/brute-force-prototype/src/main/java/edu/uga/devdogs/bruteforceprototype/BruteForcePrototype.java

@@ -7,7 +7,6 @@
 import edu.uga.devdogs.sampledataparser.records.SConstraints;
 import edu.uga.devdogs.sampledataparser.records.Section;
 
-import java.sql.Array;
 import java.util.*;
 
 public class BruteForcePrototype {
@@ -42,9 +41,6 @@ public static int[][] algorithmDriver(Set<Course> inputCourses, Map<String, Map<
             return optimize(outputCourses, distances, softConstraints,false);
         } catch (Exception e){
             // If an exception arises from dataPreSoftFilter, we will call an overloaded version of optimize().
-            // The overloaded version is not written yet, so when it is actually implemented,
-            // this catch block will need updated accordingly.
-            System.out.println(e.getMessage());
             //outputCourses = BruteForceUtil.dayOfWeekConvert(outputCourses);
             return optimize(outputCourses, distances, softConstraints, true);
         }
@@ -76,7 +72,7 @@ public static int[][] optimize(Set<Course> inputCourses, Map<String, Map<String,
         List<Schedule> sortedSchedules = new ArrayList<>();
         List<Double> sortedOverallObjectives = new ArrayList<>();
 
-        
+
         // Makeshift Priority Queue; An array sorted by a variable (in this case, overallObjective).
         // Before an item is added, you find where it should be placed so that the List is still sorted correctly
         // Without having to call a special sorting function.
@@ -167,8 +163,8 @@ private static void generateValidSchedulesRecursive(Set<Section> sections, List<
             // Instantiates the set of sections for the next iteration
             HashSet<Section> nextSections = new HashSet<>(sections);
             nextSections.add(sectionToAdd);
-            
+
             generateValidSchedulesRecursive(nextSections, nextCoursesToAdd, validSchedules);
         }
     }
-}
+}

algorithm-prototyping/brute-force-prototype/src/main/java/edu/uga/devdogs/bruteforceprototype/BruteForceUtil.java

@@ -2,6 +2,7 @@
 
 import edu.uga.devdogs.sampledataparser.records.*;
 import edu.uga.devdogs.sampledataparser.records.Class;
+import edu.uga.devdogs.bruteforceprototype.schedule.Schedule;
 
 import java.time.DayOfWeek;
 import java.util.ArrayList;
@@ -157,8 +158,9 @@ public static DayOfWeek daySwitch(String day) {
      *
      * @param inputCourses user inputted courses.
      * @param validSchedules a set of valid generated schedules
+     * @throws Exception if {@code courseInSchedule} if true
      */
-    public static void ensureInitialCourses(Set<Course> inputCourses, Set<Schedules> validSchedules) {
+    public static void ensureInitialCourses(Set<Course> inputCourses, Set<Schedule> validSchedules) throws Exception {
         boolean courseInSchedule = false;
         // for every user inputted course
         for (Course c : inputCourses) {
@@ -167,12 +169,12 @@ public static void ensureInitialCourses(Set<Course> inputCourses, Set<Schedules>
                 // for every section in said schedule
                 for (Section sect : s.sections()) {
                     // if the course the user inputted, c, is in the schedule, s
-                    if (c.courseCode == sect.courseCode) {
+                    if (c.courseCode().equals(sect.courseCode())) {
                         courseInSchedule = true;
                     } // if
                 } // for
                 if (!courseInSchedule) {
-                    throw new Exception("Schedule does not contain specified course.")
+                    throw new Exception("Schedule does not contain specified course.");
                 } // if
             } // for
         } // for

algorithm-prototyping/brute-force-prototype/src/main/java/edu/uga/devdogs/bruteforceprototype/schedule/Schedule.java

@@ -65,5 +65,4 @@ public Set<Section> sections() {
     public EnumMap<DayOfWeek, TreeSet<Class>> days() {
         return days;
     }
-}
-
+}

algorithm-prototyping/brute-force-prototype/src/main/java/edu/uga/devdogs/bruteforceprototype/schedule/ScheduleUtil.java

@@ -5,12 +5,20 @@
 import edu.uga.devdogs.sampledataparser.records.Class;
 import edu.uga.devdogs.sampledataparser.records.HConstraints;
 
+//import edu.uga.devdogs.course_information.service;
+//import org.springframework.beans.factory.annotation.Autowired;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeSet;
+import java.util.EnumMap;
 import java.util.Set;
 
+import java.time.DayOfWeek;
+import java.time.LocalTime;
+
+
 
 /**
  * Utility class for performing operations and calculations related to a Schedule.
@@ -22,6 +30,10 @@
  */
 public class ScheduleUtil {
 
+    // Used for bootstrap getting coords
+    //@Autowired
+    //private CourseInformationService courseInformationService;
+
     /**
      * Validates the given schedule by checking for any time conflicts between classes.
      * A time conflict occurs when two classes overlap in their scheduled times.
@@ -86,7 +98,7 @@ public static double computeAverageProfessorQuality(Schedule schedule) {
 
     /**
      * Checks if schedule or constraints is null and throws an exception if it is.
-     * 
+     *
      * @param schedule the schedule to validate
      * @param constraints the constraints to validate
      */
@@ -115,22 +127,46 @@ public static double computeMaxDistance(Schedule schedule, Map<String, Map<Strin
         // Iterates over each day in the schedule
         for (TreeSet<Class> day : schedule.days().values()) {
             // Converts the TreeSet to List for direct indexing
-            // TODO: Replace TreeSet with a sorted List for days in Schedule
             List<Class> dayList = new ArrayList<>(day);
 
             // Iterates over consecutive class pairs
             for (int i = 0; i < dayList.size() - 1; i++) {
                 Class currClass = dayList.get(i);
                 Class nextClass = dayList.get(i + 1);
-                double distance = distances.get(currClass.buildingName()).get(nextClass.buildingName());
+
+                double lat1 = 0.0;//courseInformationService.getLatitude(currClass.buildingNumber());
+                double lon1 = 0.0; //courseInformationService.getLongitude(currClass.buildingNumber());
+                double lon2 = 0.0; //courseInformationService.getLongitude(nextClass.buildingNumber());
+                double lat2 = 0.0; //courseInformationService.getLatitude(nextClass.buildingNumber());
+
+                // distance between latitudes and longitudes
+                double dLat = Math.toRadians(lat2 - lat1);
+                double dLon = Math.toRadians(lon2 - lon1);
+
+                // convert to radians
+                lat1 = Math.toRadians(lat1);
+                lat2 = Math.toRadians(lat2);
+
+                // apply Haversine formula
+                double a = Math.pow(Math.sin(dLat / 2), 2) +
+                        Math.pow(Math.sin(dLon / 2), 2) *
+                                Math.cos(lat1) *
+                                Math.cos(lat2);
+
+                // Earth's radius in miles
+                double rad = 3960;
+                double c = 2 * Math.asin(Math.sqrt(a));
+                double distance = rad * c;
 
                 if (distance > maxDistance) {
                     maxDistance = distance;
                 }
             }
         }
 
-        return maxDistance;
+        // dimensional analysis. Average human walking speed is 3 miles per hour.
+        // miles * (hours/miles) * (minutes/hours)
+        return maxDistance * (1/3) * (60);
     }
 
     /**
@@ -174,6 +210,63 @@ public static double computeAverageIdleTime(Schedule schedule) {
         return (double) sumOfTimeGaps / countOfClassGaps;
     }
 
+
+
+    /**
+     * Computes the earliest start time of all classes in a schedule
+     *
+     * @param schedule the schedule for which to compute the earliest start time
+     * @return the earliest start time (in hours) as a double. For example, 4:30 pm would be represented as 16.5
+     */
+    public static double computeStartTime(Schedule schedule) {
+        LocalTime earliestStartTime = LocalTime.of(23,59,59);
+        for (Section eachSection : schedule.sections()) {
+            for (Class eachClass : eachSection.classes()) {
+                if (eachClass.startTime().isBefore(earliestStartTime)) {
+                    earliestStartTime = eachClass.startTime();
+                }
+            }
+        }
+        return earliestStartTime.getHour() + (double) earliestStartTime.getMinute() / 60;
+    }
+
+
+
+    /**
+     * Computes the latest start time of all classes in a schedule
+     *
+     * @param schedule the schedule for which to compute the latest start time
+     * @return the latest start time (in hours) as a double. For example, 4:30 pm would be represented as 16.5
+     */
+    private static double computeEndTime(Schedule schedule) {
+        LocalTime latestStartTime = LocalTime.of(0,0,0);
+        for (Section eachSection : schedule.sections()) {
+            for (Class eachClass : eachSection.classes()) {
+                if (eachClass.startTime().isAfter(latestStartTime)) {
+                    latestStartTime = eachClass.startTime();
+                }
+            }
+        }
+        return latestStartTime.getHour() + (double) latestStartTime.getMinute() / 60;
+    }
+
+
+
+    /**
+     * Determines whether a given schedule has zero classes on a given day
+     *
+     * @param schedule the schedule for which to compute whether it has a gap day or not
+     * @param gapDay the day that is being checked as a gap day or not
+     * @return {@code true} if the given schedule has no classes on the given day, {@code false} if it has at least one class
+     */
+    private static boolean computeGapDay(Schedule schedule, DayOfWeek gapDay) {
+        EnumMap<DayOfWeek, TreeSet<Class>> days = schedule.days();
+        TreeSet<Class> classes = days.get(gapDay);
+        return classes.isEmpty();
+    }
+
+
+
     /**
      * Computes the overall objective score for the given schedule based on weighted objectives.
      * This method computes each objective, normalizes their values using min-max normalization, and computes a weighted sum.
@@ -185,10 +278,10 @@ public static double computeAverageIdleTime(Schedule schedule) {
      * @return the overall objective score for the schedule
      */
     public static double computeOverallObjective(Schedule schedule, Map<String, Map<String, Double>> distances) {
-       // Checks if the parameters are valid
-       if (schedule == null || distances == null) {
-           throw new IllegalArgumentException("Parameters cannot be null");
-       }
+        // Checks if the parameters are valid
+        if (schedule == null || distances == null) {
+            throw new IllegalArgumentException("Parameters cannot be null");
+        }
 
         // The minimum rating on rate my professor is 1.0(if they have ratings).
         final double professorQualityMinimum = 1.0;
@@ -251,7 +344,7 @@ public static double computeOverallObjectiveExtended(Schedule schedule, Map<Stri
             possSConstraintsCount++;
         }
         if (softConstraints.prefStartTime() != null) {
-            possSConstraintScore += normalizeValue(computeStartTime(schedule), prefTimeMinimum, prefTimeMaximum);;
+            possSConstraintScore += normalizeValue(computeStartTime(schedule), prefTimeMinimum, prefTimeMaximum);
             possSConstraintsCount++;
         }
         if (softConstraints.prefEndTime() != null) {
@@ -310,4 +403,4 @@ public static int[] sectionsToInts(Set<Section> sections) {
         return output;
     }
 
-}
+}