apis/examples_python/markowitz_8py_source.html

from gams import *

import sys

import os

from math import fabs


try:

    import matplotlib.pyplot as plt

except:

    raise Exception("This example requires the matplotlib module")


def get_model_text():

    return '''

$title Standard Markowitz Portfolio Selection Model


set s selected stocks

    upper(s,s), lower(s,s) parts of covar matrix;

alias(s,t);


parameter mean(s)    mean of daily return

          covar(s,s) covariance matrix of returns (upper);


$if not set data $abort 'no include file name for data file provided'

$gdxin %data%

$load s covar upper lower mean


variables z      objective variable

          ret    return

          var    variance

          x(s)   investments;


positive variables x;


equations obj    objective

          budget

          varcon variance constraint

          retcon return constraint;


scalar lambda /0/;


obj..    z =e= lambda*ret - (1-lambda)*var;

budget.. sum(s, x(s)) =e= 1.0;

varcon.. var =e= sum(upper(s,t), x(s)*covar(s,t)*x(t)) +

                 sum(lower(s,t), x(s)*covar(t,s)*x(t));

retcon.. ret =e= sum(s, mean(s)*x(s));


model markowitz /all/; '''


if __name__ == "__main__":

    if len(sys.argv) > 1:

        ws = GamsWorkspace(system_directory = sys.argv[1])

    else:

        ws = GamsWorkspace()


    job = ws.add_job_from_string(get_model_text())

    opt = ws.add_options()

    opt.all_model_types = "conopt"

    opt.defines["data"] = "\"" + os.path.join(os.path.dirname(os.path.realpath(__file__)), "..\\Data\\markowitz.gdx") + "\""


    cp = ws.add_checkpoint()

    job.run(opt, cp)

    mi = cp.add_modelinstance()

    l = mi.sync_db.add_parameter("lambda", 0, "")

    mi.instantiate("markowitz use nlp max z", GamsModifier(l))


    # a list for collecting the data points

    data_points = []


    # get minimum and maximum return (lambda=0/1)

    l.add_record().value = 0

    mi.solve()

    min_ret = mi.sync_db["ret"].first_record().level

    data_points.append( (min_ret, mi.sync_db["var"].first_record().level) )

    l.first_record().value = 1

    mi.solve()

    max_ret = mi.sync_db["ret"].first_record().level

    data_points.append( (max_ret, mi.sync_db["var"].first_record().level) )


    # gap that specifies the max distance (return) between two data points

    gap = 0.02

    # a list (stack) of intervals, where an interval is represented by a 2-tuple containing two data points

    # each represented by a 2-tuple as well (lambda, return)

    intervals = [((0.0, min_ret), (1.0, max_ret))]


    # Algorithm that solves the model instance for multiple lambda values

    # using a max gap between two data points to achieve a smooth graph.

    # Lambda is dynamically calculated for an even distribution of data points

    while intervals:

        # pick the first interval and calculate a new value for lambda

        i = intervals.pop()

        min_l, min_ret = i[0][0], i[0][1]

        max_l, max_ret = i[1][0], i[1][1]


        l_val = (min_l+max_l)/2

        l.first_record().value = l_val

        # solve the model instance with the new lambda value

        mi.solve()

        # retrieve the return and variance results

        cur_ret = mi.sync_db["ret"].first_record().level

        data_points.append( (cur_ret, mi.sync_db["var"].first_record().level) )

        # add new intervals if the gap is still to big

        if cur_ret - min_ret > gap:

            intervals.append(((min_l, min_ret), (l_val, cur_ret)))

        if fabs(cur_ret - max_ret) > gap:

            intervals.append(((l_val, cur_ret), (max_l, max_ret)))


    # Sort data points and make two list for the plot function

    data_points.sort(key=lambda tup: tup[0])

    ret = map(lambda x: x[0], data_points)

    var = map(lambda x: x[1], data_points)

    plt.plot(ret, var, marker=".", markersize=10)

    plt.xlabel('return')

    plt.ylabel('variance')

    plt.show()