Add files via upload

Author: khchuang12

InfectionTracking.java

@@ -0,0 +1,356 @@
+/**
+ * This program is used to simulate hypothetical COVID-19 transmission
+ * simulations as well as collect data regarding how the virus would
+ * spread if all students went about their lives without taking any
+ * precautionary measures. This simulation includes the following
+ * factors: populating lists of who is infected, their names,
+ * their movement, the world size, how many people they infected,
+ * the average number of infections, as well as the name of the
+ * individual with the most infections after a certain number of days
+**/
+import java.util.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.FileInputStream;
+/**
+* This class contains all of the methods to simulate the hypothetical
+* COVID-19 transmission simulation. These methods include a couple
+* isValid methods, populateArrays method, updateLocations, updateInfections,
+* countInfectionsByStudent, findRNaught, and findSuperSpreader.
+**/
+public class InfectionTracking{
+/**
+* This method checks the validity of each value in the different arrays.
+* The method checks to see if the inputs for each array are valid or not
+* and returns a boolean statement to ensure validity or not.
+* The method checks to see if the lengths of each array match each other,
+* if any of the input arrays is null, and if the infection array values
+* are either a 1 or 0.
+*
+* @param names - array for student names
+* @param locations - array for locations
+* @param movements - array for movement between locations
+* @param infections - array for infections
+* @param worldSize - size of 1-dimensional world
+* @param pathToFile - file path
+*
+**/
+  public static boolean isValid(String[] names, int[] locations,
+  int[] movements, int[] infections){
+    if(names==null||locations==null||movements==null||infections==null){
+      return false;
+    }
+    for(int i=0;i<locations.length;i++){
+      if(locations[i]<0){
+        return false;
+      }
+    }
+    if(names.length!=locations.length||locations.length!=movements.length||
+    movements.length!=infections.length||infections.length!=names.length){
+      return false;
+    }
+    boolean infectionBool = false;
+    for(int j=0;j<infections.length;j++){
+      if(infections[j]==0||infections[j]==1){
+        infectionBool = true;
+      }else{
+      infectionBool=false;
+      }
+    }
+    return infectionBool;
+  }
+/**
+* This method checks the validity with the introduciton of a new
+* parameter: worldSize
+* This method makes sure none of the arrays are null, the locations
+* array and the movements array have the same length, the worldSize
+* is between 0 and worldSize-1
+* @param locations - array of locations as integers
+* @param movements - array of movements between locations as integers
+* @param worldSize - int indicating size of world
+* returns boolean checking validity of these tests
+**/
+  public static boolean isValid(int[] locations,int[] movements,
+  int worldSize){
+    if(locations==null||movements==null||
+    locations.length!=movements.length||worldSize<0){
+      return false;
+    }
+    for(int i=0;i<locations.length;i++){
+      if(locations[i]<0||locations[i]>(worldSize-1)){
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+  * This method checks the validity with respect to different
+  * parameters: locations, worldSize, and infecttions
+  * This method makes sure none of the arrays are null, the locations
+  * array and the infections array have the same length, the worldSize
+  * is between 0 and worldSize-1
+  * @param locations - array of locations as integers
+  * @param infections - array of infections either 1 or 0
+  * @param worldSize - int indicating size of world
+  * returns boolean checking validity of these tests
+  **/
+  public static boolean isValid(int[] locations,
+  int worldSize,int[] infections){
+    if(locations==null||infections==null){
+      return false;
+    }
+    if(worldSize<0){
+       return false;
+    }
+    for(int i=0;i<locations.length;i++){
+      if(locations[i]<0||locations[i]>(worldSize-1)){
+        return false;
+      }
+    }
+    boolean sameLength = locations.length==infections.length;
+    for(int j=0;j<infections.length;j++){
+      if(infections[j]!=0&&infections[j]!=1){
+        return false;
+      }
+    }
+    return sameLength;
+  }
+  /**
+  * This method is used to populate empty arrays from the text file
+  * that is imported by this method also. The method imports a file
+  * and scans through it getting the individual values from it
+  * and populating arrays according to those values. These arrays
+  * include names, locations, movements, infections
+  * The method returns -1 if the arrays are not properly populated
+  * and returns the max locations value+1 if properly populated
+  *
+  * @param pathToFile - file path
+  * @param names - array of names
+  * @param locations - array of locations as integers
+  * @param infections - array of infections either 1 or 0
+  * @param worldSize - int indicating size of world
+  * @param movements - array of movements between locations as integers
+  * returns max locations value+1 if populated correctly
+  * returns -1 if populated incorrectly
+  **/
+  public static int populateArrays(String pathToFile, String[] names,
+  int[] locations, int[] movements, int[] infections) throws IOException{
+    if(pathToFile!=null&&isValid(names,locations,movements,infections)){
+      FileInputStream filePath = new FileInputStream(pathToFile);
+      Scanner sc = new Scanner(filePath);
+      int i =0;
+      while(sc.hasNextLine()){
+      // goes thru each line in text file splitting strings by the ","
+      // this gets the individual values to go in each array
+        String str[]=sc.nextLine().split(",");
+        String name = str[0];
+        int location = Integer.parseInt(str[1]);
+        int movement = Integer.parseInt(str[2]);
+        int infection = Integer.parseInt(str[3]);
+        names[i]=name;
+        locations[i] = location;
+        movements[i] = movement;
+        infections[i] = infection;
+        i=i+1;
+      }
+      sc.close();
+      // loops thru finding max value
+      int maxVal = locations[0];
+      for(int j=0;j<locations.length;j++){
+        if(maxVal<locations[j]){
+          maxVal = locations[j];
+        }
+      }
+      int max = maxVal+1;
+      return max;
+    }else{
+      return -1;
+    }
+  }
+  /**
+  * This method updates the locations of the individuals based on their
+  * movements and updates the current location after the movement. It
+  * also checks that the movements stay within the worldsize and wraps
+  * back the location using the modulus operator to ensure the movement
+  * stays within the worldSize
+  *
+  * @param modulo - modulus of the new location divided by the worldSize
+  * @param worldSize - int indicating size of world
+  * @param movements - array of movements between locations as integers
+  * @param locations - array of locations as integers
+  *
+  **/
+  public static void updateLocations(int worldSize, int[] locations,
+  int[] movements){
+    if(isValid(locations,movements,worldSize)==true){
+      for(int i=0;i<locations.length;i++){
+        // check validity of input
+        if(locations[i]+movements[i]<0||locations[i]+movements[i]>=worldSize){
+          int modulo = (locations[i]+movements[i])%worldSize;
+          // if new location is negative
+          if(modulo<0){
+            locations[i]=modulo+worldSize;
+          // if new location is not neg and > worldSize
+          }else{
+            locations[i]=modulo;
+          }
+          // if new location is not negative and < worldSize
+        }else{
+          locations[i] = locations[i]+movements[i];
+        }
+      }
+    }
+  }
+  /**
+  * This method updates the infections of students who come into contact
+  * with each other or are in the same location at one point. The method
+  * takes the locations and worldSize ensureing not to go out of bounds,
+  * and counds how many individuals a student has infected based upon
+  * their contact at their shared location. The method creates a new array
+  * keeping track of all the students and the number of other students
+  * they infect.
+  *
+  * @param modulo - modulus of the new location divided by the worldSize
+  * @param worldSize - int indicating size of world
+  * @param infections - array of infections either 1 or 0
+  * @param locations - array of locations as integers
+  * returns the newly created array that keeps track of the number of
+  * students that were infected by the student at the index
+  *
+  **/
+  public static int[] updateInfections(int worldSize, int[] locations,
+  int[] infections){
+    if(isValid(locations,worldSize,infections)==true){
+      int[] numStudentsInfected= new int[infections.length];
+      // loops thru adding to numStudentsInfected for each student infected
+      for(int i=0;i<infections.length;i++){
+        if(infections[i]==1){
+          for(int j=0;j<locations.length;j++){
+            if(locations[i]==locations[j]&&infections[j]==0){
+              numStudentsInfected[i] = numStudentsInfected[i]+1;
+            }
+          }
+        }
+      }
+      // loops through changing all the infected to 1's
+      for(int i=0;i<infections.length;i++){
+        if(infections[i]==1){
+          for(int j=0;j<infections.length;j++){
+            if(locations[i]==locations[j]&&infections[j]==0){
+              infections[j]=1;
+            }
+          }
+        }
+      }
+      return numStudentsInfected;
+    }
+    return null;
+  }
+  /**
+  * This method creates a new array called infectionRecord and updates
+  * the locations of students after their movements each day and
+  * records the number of people they have infected or got infected in
+  * the shared location
+  *
+  * @param worldSize - int indicating size of world
+  * @param infections - array of infections either 1 or 0
+  * @param locations - array of locations as integers
+  * @param movements - array of movements between locations as integers
+  * @param infectionRecord - array of infections over a number of days
+  * returns the newly created array that keeps track of the number of
+  * students that were infected by the student at the index after
+  * a certain number of days
+  *
+  **/
+  public static int[] countInfectionsByStudent(int days, int worldSize,
+  int[] locations, int[] movements, int[]infections){
+    // checks validity of inputs
+    if(isValid(locations,worldSize,infections)==true&&
+    isValid(locations, movements, worldSize)==true&&days>=0){
+      int[] infectionRecord = new int[locations.length];
+      for(int i=0;i<days;i++){
+        updateLocations(worldSize,locations,movements);
+    // create new array to store new values to add infectionRecord
+        int[] parallelArr = updateInfections(worldSize, locations, infections);
+        for(int j=0;j<infections.length;j++){
+          infectionRecord[j] = infectionRecord[j]+parallelArr[j];
+        }
+      }
+      return infectionRecord;
+    }else{
+      return null;
+    }
+  }
+  /**
+  * This method takes the newly created array from countInfectionsByStudent
+  * and checks to see its validity if it is not null and not equal to 0.
+  * It also checks to see none of the values in the array are negative and
+  * takes the values in the array and adds them up to find the average
+  * number of people infected by a single individual student
+  *
+  * @param infectionRecord - array of infections over a number of days
+  * returns -1 if input is invalid
+  * returns average number of infections by a single student
+  **/
+  public static int findRNaught(int[] infectionRecord){
+    // checks validity of input
+    if(infectionRecord==null||infectionRecord.length==0){
+      return -1;
+    }
+    for(int i=0;i<infectionRecord.length;i++){
+      if(infectionRecord[i]<0){
+        return -1;
+      }
+    }
+    int sum=0;
+    for(int j=0; j<infectionRecord.length;j++){
+      sum = sum+infectionRecord[j];
+    }
+    // math ceiling allows the value to always be rounded up
+    int avg = (int)Math.ceil(((double)sum)/infectionRecord.length);
+    return avg;
+  }
+  /**
+  * This method takes the array from countInfectionsByStudent
+  * and checks to see its validity if it is not null and not equal to 0.
+  * It also checks to see none of the values in the array are negative and
+  * also makes sure the names array and infectionRecord array are equal
+  * in length. It also loops through the infectionRecord array
+  * and finds the highest infection number and uses that index to
+  * locate the name of the individual responsible for the highest
+  * spread of COVID-19
+  *
+  * @param infectionRecord - array of infections over a number of days
+  * returns null if input is invalid
+  * returns name of SuperSpreader
+  **/
+  public static String findSuperSpreader(int[] infectionRecord,
+   String[] names){
+     // checks validity of input
+     if(infectionRecord==null||infectionRecord.length==0||
+     names==null||names.length==0){
+       return null;
+     }
+     if(infectionRecord.length!=names.length){
+       return null;
+     }
+     for(int i=0;i<infectionRecord.length;i++){
+       if(infectionRecord[i]<0){
+         return null;
+       }
+     }
+    // loops thru to find max infeciton value
+    int maxInfect=infectionRecord[0];
+    int index = 0;
+    for(int j=0;j<infectionRecord.length;j++){
+      if(maxInfect<infectionRecord[j]){
+        maxInfect = infectionRecord[j];
+        index = j;
+      }
+    }
+    // uses max infection value index to find name
+    String namesIndex=names[index];
+    return namesIndex;
+  }
+}