Suppose that from this table we want to generate the following MATLAB matrix storing amount information.

To do that we need to map each date and ID with an index. We use containers.Map objects. See Matlab Map Containers page to learn more.

Next step is to fill matrix Amount. Consider a m x n matrix A. Suppose we want to use matrix B = (1,1;1 2) for selecting elements of A. Unfortunetely A(B(:,1), B(:,2)) will not work. We should use linear indexing. See Matrix indexing to learn more.

MATLAB code:

T1 = ['29.10.2011'; '30.10.2011'; '29.10.2011'; '30.10.2011'; '31.10.2011'; '1.11.2011'; '1.11.2011'];
T2 = [1001; 1001; 1002; 1002; 1002; 1001; 1002];
T3 = [10.2; 15.6; 17.5; 12.2; 7.9; 19.3; 17;9 ];

keySet = {'29.10.2011', '30.10.2011', '31.10.2011', '01.11.2011'};
valueSet = 1:4;

date_index = containers.Map(keySet,valueSet);

keySet = {1001, 1002};
valueSet = 1:2;

id_index = containers.Map(keySet,valueSet);

Amount = ones(2,4)*NaN;

Amount(sub2ind(size(Amount), values(date_index,T1), values(id_index,T2) )  ) = T3

You can also index dates by using Matlab’s datenum function. This function returns how many days is passed from a reference point (1-Jan-0000). Suppose D matrix contains a list of dates then the following code will also work:

D = {'29.10.2011', '30.10.2011', '29.10.2011', '30.10.2011', '31.10.2011', '01.11.2011'}
datenum(D) - min(datenum(D))

There are polynomial time exact coloring algorithms for some subclass of graphs:

• Interval graphs
• Chordal graphs (triangulated graphs)
• Permutation graphs

All the graph classes above are part of a general graph class called Perfect Graphs. In all perfect graphs, the graph coloring problem can be solved in polynomial time.

On the other hand, there are various coloring heuristic algorithms in the literature. One of the simplest one is the following:

1. Make a non-increasing order of the vertices according to their degrees
2. Consider one by one the vertices with this order and color them with the first available color (which does cause an infeasibility, if there no such a color exist create a new color)

Another popular coloring algorithm is Brelaz’s DSATUR algorithm. There are two versions (exact and heuristic) of the algorithm. Here we will consider the heuristic (greedy) version of the algorithm.

Suppose we are given a graph and a partial coloring of this graph (some of the vertices are already colored). We define saturation degree of a vertex as the number of different colors in the neighborhood of that vertex. In DSATUR algorithm, vertices are selected one by one with the following rule and are given the first available color.

Dynamic Order: Select a vertex v with the highest saturation degree, in case of tie select the one with highest (ordinary) degree. Update saturation degree values of the neighbors of v.

Matlab Code: DSATUR

function [coloring] = dsatur(V,E)

n = size(V,1);
coloring = zeros(n,1);
available_colors = 1;

% Start with the node that has the maximum degree.
% Color the current node with the lowest available color.
% Select the next node by selecting the node with the maximum degree of saturation.
% This means that you have to select the node that has the most number of unique neighboring colors.
% In case of a tie, use the node with the largest degree.
% Goto step 2. until all nodes are colored.

% Degrees
for i=1:n
    v = i;
    Degrees(i,1) = size([E(find(E(:,1)==v),2); E(find(E(:,2)==v),1)],1);
end

% Degrees of saturation
Degrees_of_saturation = zeros(n,1);

% Coloring
for i=1:n
    if i == 1
        [value index] = max(Degrees);
        v = index(1);
        coloring(v) = 1;
        assigned_color_v = 1;
    else
        Uncolored = find(coloring==0);
        index_temp = find(Degrees_of_saturation(Uncolored)==max(Degrees_of_saturation(Uncolored)));
        index = Uncolored(index_temp);
        if(size(index,1)>1)
            [value1 index1] = max(Degrees(index));
            v = index(index1);
        else
            v = index;
        end

        % Assign first available color to v
        neighbors = [E(find(E(:,1)==v),2); E(find(E(:,2)==v),1)];
        for j=1:available_colors
            if size(find(coloring(neighbors)==j),1)==0
                coloring(v) = j;
                assigned_color_v = j;
                break;
            end
        end
        if coloring(v) == 0
            available_colors = available_colors + 1;
            coloring(v) = available_colors;
            assigned_color_v = available_colors;
        end
    end

    % Update Degrees of saturation
    neighbors_v = [E(find(E(:,1)==v),2); E(find(E(:,2)==v),1)];
    for j=1:size(neighbors_v,1)
       u = neighbors_v(j);
       neighbors_u = [E(find(E(:,1)==u),2); E(find(E(:,2)==u),1)];
       if size(find(coloring(neighbors_u)==assigned_color_v),1) == 1
           Degrees_of_saturation(u,1) = Degrees_of_saturation(u,1) + 1;
       end
    end

end

Erdős–Gallai theorem gives us necessary and sufficient conditions for this problem.

the sum of the sequence is even and

Suppose the degree sequence is graphical then the following simple procedure construct a possible graph implementation from this given degree sequence.

Pseudocode: Havel-Hakimi

• Begin with no edges
• Start residual degree requirement values with the given degree sequence
• While residual degree requirement of some vertex is non-zero
• Sort vertices in non-increasing order of residual degree requirement
• Make an edge between first vertex and the next vertices in the previous list
• Update residual degree requirements

Matlab Code: Havel-Hakimi

function E = mcmc_graph(degree_sequence)

n = size(degree_sequence,2);
% Check if the given degree sequence is graphical
degree_sequence_feasible = 1;
if mod(sum(degree_sequence),2)
    degree_sequence_feasible = 0;
else
    sorted_degree_sequence = sort(degree_sequence,'descend');
    for k=1:n
        temp_sum = 0;
        for i=k+1:n
            temp_sum = temp_sum + min(sorted_degree_sequence(i),k);
        end
        if (sum( sorted_degree_sequence(1:k)) > k*(k-1) + temp_sum )
            degree_sequence_feasible = 0;
        end
    end
end

m = sum(degree_sequence)/2;
E = zeros(m,2);

% Construct an initial graph with Havel-Hakini
if degree_sequence_feasible
    ds = degree_sequence;
    i = 0;
    while sum(ds) > 0
        [residual_degree vertices] = sort(ds,'descend');
        selected_vertices = vertices(2:residual_degree(1)+1);
        E(i+1:i+residual_degree(1),:) = ...
            [repmat(vertices(1),residual_degree(1)) selected_vertices'];
        i = i + residual_degree(1);
        ds(vertices(1)) = ds(vertices(1)) - residual_degree(1);
        ds(selected_vertices) = ds(selected_vertices) - 1;
    end

Let be a set of points in . If the intersection of all possible of these sets are non empty then the whole intersection is non-empty also.

For example, let’s consider a set of paths in . Then if all couple of paths has a non-empty intersection then the intersection of all paths is also non-empty.

On the other hand, in let’s consider a set of unit circles . Observe that even if all couple of circles are touching this does not imply that the intersection is not empty.

Every two circles intersect but the intersection of all circles are empty

But by Helly’s Theorem we know that if all triples of circles are intersect implies that the total intersection is not empty.

Helly’s Family and Helly Property

We say that a family of sets (for example set of circles in ) is a Helly Family of order if is the minimal number such that non-empty intersection of subsets of size has a non-empty total intersection. The -Helly property is the property of being a Helly family of order . A 2-Helly family is also known as a Helly family and the 2-Helly property is also known as the Helly property.

Helly Property in Graph Thoery

It is possible to derive maximum clique algorithms for special graph classes like interval graphs or unit disk graphs using this property.

• Some definitions: Degeneracy, Total unimodularity, Shadow price, Reduced Cost, Sensitivity analysis, minkowski theorem
• Primal and dual simplex methods
• Big-M, Two phase methods
• Theory of simplex method
• Duality
• Fundemental problems and their mathematical formulations: matching, assignment, shortest path, maximum flow
• Linear programming modeling tips: absolute value, etc.
• Integer programming modeling tips: m constraints among n constraints, etc.
• Decomposition methods: Dantzig-Wolfe, Bender’s

Nonlinear Programming

• Some definitions: Convex set, convex function
• Optimality conditions
• Newton’s and secant methods
• Positive definite matrices
• Steepest descent
• Geometric programming
• Duality (Lagrangean)

Probability & Statistics

• Some definitions: Bayes theorem, Maximum likelihood, Exponential family, Canonical parametrization, Expectation, Variance, Law of large numbers, Central limit theorem
• Basic dicrete probability distributions: Bernoulli, Binomial, Multinomial, etc.
• Basic continous probability distributions: Normal, Poisson, Beta, Gamma, etc.
• Bayesian aproach vs Frequentist aproach
• Condition probability
• Hypothesis testing
• ANOVA

Stochastic Processes

• State transition modeling
• Birth-death processes
• Poisson processes
• Queuing theory
• Markov chains
• Renewal-Reward processes