Master

README.md

@@ -1,4 +1,4 @@
-# MATLAB Fall 2014 – Research Plan (Template)
+# MATLAB Fall 2017 – Research Plan (Template)
 (text between brackets to be removed)
 
 > * Group Name: (be creative!)

code.m

@@ -0,0 +1,100 @@
+%{
+GENERAL NOTES
+=============
+
+Each function should be defined in a separate file according
+to MATLAB requirements. Upload these files to the code folder
+in the repository.
+When iterating over the matrix, if possible, parallelize the
+accesses using parfor to increase efficiency. To iterate over
+the people inside of one sector, use the following piece of
+code:
+
+itr = matrix(i, j).iterator();
+
+while itr.hasNext()
+    person = itr.next();
+    % Do something with that person
+end
+
+Inside the matrix, the position of the individual is represented in
+absolute terms (i.e. relative to the entire matrix, not the sector). For
+precision reasons, the coordinates range from 0 to 10 * resolution (for
+now, we can always make it finer-grained by changing the SECTOR_SIZE
+global).
+
+To convert coordinates to a sector, use the function
+sectorForCoords(individual). You can also pass pure coordinates to this
+function.
+
+Define all globals in the runSimulation.m file. This way, the parameters of
+the simulation are easy to find and change.
+
+=============
+%}
+
+% Definition of individual
+
+%{
+An individual is a vector with 
+- positionX
+- positionY
+- velocityX
+- velocityY
+- isParticipating in moshpit
+%}
+
+%{
+Initializes the position matrix. The ground covered by the people
+attending the concert is divided into sectors. The people in
+each sector are represented with a java.util.LinkedList.
+The coordinates of each person are given as absolute coordinates,
+i.e. not relative to the sector, but to the entire matrix.
+%}
+function initializeMatrix()
+end
+
+% Gets the position of the given individual
+function [position] = getPosition(individual)
+end
+
+% Gets the velocity of the given individual
+function [velocity] = getVelocity(individual)
+end
+
+% Returns true if the given individual is participating in the circle pit
+function [isParticipating] = isParticipating(individual)
+end
+
+% Returns the distance between two individuals
+function [distance] = distance(individual1, individual2)
+end
+
+%{
+Returns the neighbors of the given individual as a matrix where each column
+is an individual.
+%}
+function [neighbors] = getNeighbors(individual)
+end
+
+% TODO
+%{
+Main loop that iterates through the individuals and updates all their
+positions, returning the modified main matrix.
+%}
+function runOneTimestep(matrix)
+end
+
+% TODO
+%{
+Runs the simulation.
+%}
+function runSimulation()
+    initializeMatrix();
+    for i = 1:MAX
+        runOneTimestep(matrix);
+    end
+end
+
+
+

code/README.md

@@ -1,3 +1,6 @@
 # Code Folder 
 
-Your code goes here. You could also replace the content of this file with something more meaningful
+Contains the code for the MATLAB implementation of the project.
+The structure of the code is laid out in the `code.m` file in the root directory of the repository.
+
+__WARNING__: The MATLAB version was retired on November 17, 2017 and is obsolete. We have moved to Java for speed reasons. See the `java_code` folder for the most recent version.

code/createIndividual.m

@@ -0,0 +1,8 @@
+function [individual] = createIndividual(coordinates, velocity, isParticipating)
+%CREATEINDIVIDUAL Creates a new individual
+%   Creates a new vector representing an individual with the specified
+%   properties.
+    individual = [coordinates(1); coordinates(2); velocity(1); velocity(2); isParticipating];
+
+end
+

code/distance.m

@@ -0,0 +1,12 @@
+function distance = distance(individual1, individual2)
+%DISTANCE Gets the distance between two individuals.
+    x1 = individual1(1);
+    y1 = individual1(2);
+    x2 = individual2(1);
+    y2 = individual2(2);
+
+    dx = x1 - x2;
+    dy = y1 - y2;
+
+    distance = sqrt(dx*dx + dy*dy);
+end

code/getNeighbors.m

@@ -0,0 +1,69 @@
+function [individuals] = getNeighbors(individual, radius)
+%GETNEIGHBORS Gets the neighbors of the given individual
+%   Gets the neighbors of an individual in the radius specified by the
+%   NEIGHBOR_SEARCH_RADIUS global. Returns these individuals as columns in
+%   a matrix.
+
+    individuals = [];
+
+    global matrix;
+
+    % Get location of the individual
+    coords = getPosition(individual);
+    sector = sectorForCoords(coords);
+
+    % Get the sectors where we need to search
+    sectorsToSearch = sector;
+    northSector = sectorForCoords(coords - [0; radius]);
+    if ~isequal(northSector, sector)
+        sectorsToSearch = [sectorsToSearch, northSector];
+    end
+
+    southSector = sectorForCoords(coords + [0; radius]);
+    if ~isequal(southSector, sector)
+        sectorsToSearch = [sectorsToSearch, southSector];
+    end
+
+    westSector = sectorForCoords(coords - [radius; 0]);
+    if ~isequal(westSector, sector)
+        sectorsToSearch = [sectorsToSearch, westSector];
+    end
+
+    eastSector = sectorForCoords(coords + [radius; 0]);
+    if ~isequal(eastSector, sector)
+        sectorsToSearch = [sectorsToSearch, eastSector];
+    end
+
+    northEastSector = sectorForCoords(coords + [radius; -radius]);
+    if ~isequal(northEastSector, sector)
+        sectorsToSearch = [sectorsToSearch, northEastSector];
+    end
+
+    northWestSector = sectorForCoords(coords + [-radius; -radius]);
+    if ~isequal(northWestSector, sector)
+        sectorsToSearch = [sectorsToSearch, northWestSector];
+    end
+
+    southEastSector = sectorForCoords(coords + [radius; radius]);
+    if ~isequal(southEastSector, sector)
+        sectorsToSearch = [sectorsToSearch, southEastSector];
+    end
+
+    southWestSector = sectorForCoords(coords + [-radius; radius]);
+    if ~isequal(southWestSector, sector)
+        sectorsToSearch = [sectorsToSearch, southWestSector];
+    end
+
+    % Search over those vectors
+    for k = 1:size(sectorsToSearch, 2)
+        i = sectorsToSearch(1, k);
+        j = sectorsToSearch(2, k);
+        itr = matrix(i, j).iterator();
+        while itr.hasNext()
+            person = itr.next();
+            if distance(individual, person) < radius
+                individuals = [individuals, person];
+            end
+        end
+    end
+end

code/getPosition.m

@@ -0,0 +1,5 @@
+function [position] = getPosition(individual)
+%GETPOSITION Gets the position of the given individual.
+    position = [individual(1); individual(2)];
+end
+

code/getVelocity.m

@@ -0,0 +1,4 @@
+function [velocity] = getVelocity(individual)
+%GETVELOCITY Gets the velocity of the given individual.
+    velocity = [individual(3); individual(4)];
+end

code/getXY.m

@@ -0,0 +1,29 @@
+function [X, Y] = getXY()
+%GETXY Gets the x and y coordinates of all the individuals for plotting.
+%   Stores the x coordinates of all the individuals in X and the
+%   corresponding y coordinates in Y.
+%   TODO: Find a way to separate the people based on isParticipating
+
+    global matrix;
+    global NUMBER_OF_PEOPLE;
+
+    X = zeros(NUMBER_OF_PEOPLE, 1);
+    Y = zeros(NUMBER_OF_PEOPLE, 1);
+
+    k = 1;
+
+    for i = 1:matrix.length
+        for j = 1:matrix(i).length
+            itr = matrix(i, j).iterator();
+            while itr.hasNext()
+                individual = itr.next();
+                position = getPosition(individual);
+                X(k) = position(1);
+                Y(k) = position(2);
+                k = k + 1;
+            end
+        end
+    end
+
+end
+

code/initializeMatrix.m

@@ -0,0 +1,46 @@
+
+function [matrix] = initializeMatrix(resolution, numberOfPeople)
+%INITIALIZEMATRIX Initializes the position matrix used by the simulation.
+%   The matrix is a low-resolution representation of the people at the
+%   concert and is divided into "sectors". Each sector can contain several
+%   people (whose position is defined by their x and y coordinates). The
+%   matrix initially contains numberOfPeople people. Each sector is a
+%   reference to a java.util.ArrayList which contains a list of the people
+%   currently in that sector.
+
+    % Initialize a matrix of the proper size
+    width = resolution(1);
+    height = resolution(2);
+
+    global SECTOR_SIZE;
+
+    % We have to use a Java array because MATLAB matrices cannot store Java
+    % objects
+    matrix = javaArray('java.util.LinkedList', width, height);
+
+    for i = 1:width
+        for j = 1:height
+            matrix(i, j) = javaObject('java.util.LinkedList');
+        end
+    end
+
+    for i = 1:numberOfPeople
+        % Generate random coordinates
+        coords(1) = rand() * width * SECTOR_SIZE;
+        coords(2) = rand() * height * SECTOR_SIZE;
+
+        % Generate random velocity
+        % TODO: Generate more sensible velocity
+        velocity = [rand() - 0.5; rand() - 0.5];
+
+        % TODO: Decide whether individual is participating
+        isParticipating = false;
+
+        individual = createIndividual(coords, velocity, isParticipating);
+
+        % Add individual to appropriate sector
+        sector = sectorForCoords(coords);
+        matrix(sector(1), sector(2)).add(individual);
+    end
+
+return;

code/isParticipating.m

@@ -0,0 +1,6 @@
+function [isParticipating] = isParticipating(individual)
+%ISPARTICIPATING Returns true if the given individual is participating in
+%the cirle pit.
+    isParticipating = individual(5);
+end
+

code/plotMatrix.m

@@ -0,0 +1,39 @@
+global matrix;
+global INDIVIDUAL_RADIUS;
+global SECTOR_SIZE;
+global MATRIX_SIZE;
+
+% try
+    close all
+    hfig = figure('NumberTitle','off','name','Moshpit simulation','MenuBar','none');
+    axis([0, SECTOR_SIZE * MATRIX_SIZE, 0, SECTOR_SIZE * MATRIX_SIZE]);
+    axis off %do not show the coordinator
+
+% while 1   
+    for i = 1:matrix.length
+        for j = 1:matrix(i).length
+            disp('Position: ');
+            disp([i, j]);
+            list = matrix(i, j);
+            itr = list.iterator();
+            while itr.hasNext()
+                individual = itr.next();
+                position = getPosition(individual);
+                x0 = position(1);
+                y0 = position(2);
+                if(isParticipating(individual))
+                    %erase mode, if the individual is participating, then
+                    %we draw a red dot, otherwise it's black
+                    head = line(x0, y0, 'color', 'r', 'Marker', '.', 'erasemode', 'xor', 'markersize', INDIVIDUAL_RADIUS * 10);
+                else
+                    head = line(x0, y0, 'color', 'k', 'Marker', '.', 'erasemode', 'xor', 'markersize', INDIVIDUAL_RADIUS * 10);
+                end
+            end
+        end
+    end
+    drawnow;  %refresh the screen
+% end 
+
+% catch
+% return 
+% end