Ejemplo n.º 1
0
def covering_model(conf_mat, len_demand):
    """
    :param conf_mat:
    :param len_demand:
    :return:
    """
    num_conf, num_shape = conf_mat.shape
    prob = LpProblem("cutting_stock", LpMinimize)  # build model
    y = LpVariable.dict("configurations",
                        range(num_conf),
                        lowBound=0,
                        cat=LpInteger)  # decision variable
    prob += lpSum(y[i] for i in range(num_conf))  # objective
    # add constraints
    for j in range(num_shape):
        prob += lpSum(y[i] * conf_mat[i, j]
                      for i in range(num_conf)) >= len_demand[j]
    prob.writeLP("cutting_stock.lp")
    prob.solve()
    # get variable values
    res = np.zeros(num_conf, dtype=int)
    for i in range(num_conf):
        val = prob.variables()[i].value()
        if val > 0.9:
            res[i] = round(val)
    return res
Ejemplo n.º 2
0
def linear_prog(numStates, numActions, rewards, transition, discount, mdpType,
                end):
    lin_prog = LpProblem("MDP", LpMinimize)
    decision_var = LpVariable.dict("value_function", range(numStates))
    LpSolverDefault.msg = 0
    # The Objective Function
    lin_prog += lpSum([decision_var[i] for i in range(numStates)])
    # adding constraints
    V = np.zeros((numStates, 1), dtype=LpVariable)
    for i in range(numStates):
        V[i][0] = decision_var[i]
    for state in range(numStates):
        for action in range(numActions):
            lowerBound = bellman_equations(transition[state][action],
                                           rewards[state][action], V, discount)
            lin_prog += decision_var[state] >= lowerBound

    if (mdpType == "episodic"):
        for i in end:
            lin_prog += (decision_var[i] == 0)

    lin_prog.solve(pulp.PULP_CBC_CMD(msg=0))
    V = np.zeros((numStates, 1))
    for i in range(numStates):
        V[i][0] = decision_var[i].varValue

    P = np.zeros((numStates, 1), dtype=int)
    tmp = np.zeros((numActions, ))
    for state in range(numStates):
        for action in range(numActions):
            tmp[action] = bellman_equations(transition[state][action],
                                            rewards[state][action], V,
                                            discount)
        P[state][0] = np.argmax(tmp)
    return P, V
Ejemplo n.º 3
0
def _eta_max(energies, productions, co2s, turn_overs, dmu_right):
    '''
    eta max
    '''
    energy_right = dmu_right.energy.total
    co2_right = dmu_right.co2.total
    turn_over_right = dmu_right.turn_over.turn_over
    produciton_right = dmu_right.production.production
    prob = LpProblem('eta max', LpMaximize)
    variables_count = len(productions)
    ingredients = [str(symbols + 1) for symbols in range(variables_count)]
    symbols = LpVariable.dict('x_%s', ingredients, lowBound=0)
    cost = dict(zip(ingredients, productions))
    prob += lpSum([cost[i] * symbols[i] for i in ingredients])
    energy_dict = dict(zip(ingredients, energies))
    turn_over_dict = dict(zip(ingredients, turn_overs))
    co2_dict = dict(zip(ingredients, co2s))
    prob += lpSum([energy_dict[i] * symbols[i]
                   for i in ingredients]) <= energy_right
    prob += lpSum([turn_over_dict[i] * symbols[i]
                   for i in ingredients]) >= turn_over_right
    prob += lpSum([co2_dict[i] * symbols[i] for i in ingredients]) == co2_right
    if prob.solve() != 1:
        logging.error('eta max unsolved situation occurs')
        raise UserWarning
    else:
        return prob.objective.value() / produciton_right
def LinearProgramming(numStates, numActions, rewards, transition, discount,
                      mdpType):
    mdpProblem = LpProblem("MDP", LpMinimize)
    dictVar = LpVariable.dict("value_function", range(numStates))
    # adding objective function
    mdpProblem += lpSum([dictVar[i] for i in range(numStates)])
    # adding constraints
    V = np.zeros((numStates, 1), dtype=LpVariable)
    for i in range(numStates):
        V[i][0] = dictVar[i]
    for state in range(numStates):
        for action in range(numActions):
            lowerBound = Bellman(transition[state][action],
                                 rewards[state][action], V, discount)
            mdpProblem += dictVar[state] >= lowerBound
    # additional constraint for episodic MDPs
    if (mdpType == "episodic"):
        mdpProblem += (dictVar[numStates - 1] == 0)
    # solve the linear programming problem
    mdpProblem.solve()
    V = np.zeros((numStates, 1))
    for i in range(numStates):
        V[i][0] = dictVar[i].varValue
    # getting the optimum policy
    P = np.zeros((numStates, 1), dtype=int)
    tmp = np.zeros((numActions, ))
    for state in range(numStates):
        for action in range(numActions):
            tmp[action] = Bellman(transition[state][action],
                                  rewards[state][action], V, discount)
        P[state][0] = np.argmax(tmp)
    return P, V
Ejemplo n.º 5
0
    def optimize_pulp(self):
        from pulp import LpVariable,LpProblem,LpMaximize,LpBinary,PULP_CBC_CMD

        p = LpProblem("knapsackP",LpMaximize)
        x = LpVariable.dict("x",indexs=(range(self.num)),lowBound=0,upBound=1,cat=LpBinary)

        #価値最大化
        #p += sum(x[i]*self.p[i].get_value() for i in range(self.num))
        #p += lpDot(x,[self.p[i].get_value() for i in range(self.num)])
        p += lpSum(x[i]*self.p[i].get_value() for i in range(self.num))

        #重量を制限以内
        p += lpSum(x[i]*self.p[i].get_weight() for i in range(self.num)) <= self.limit_weight

        #解く
        solver=PULP_CBC_CMD(msg=0,threads=10)
        p.solve(solver)

        if p.status == 1:
            print("## Pulp Optimized Result")
            self.print([int(x[i].value()) for i in range(self.num)])
            ret = sum([x[i].value()*self.p[i].get_value() for i in range(self.num)])
            del x,p
            gc.collect()
            return ret
        else:
            print("## Pulp Optimizing Failed")
Ejemplo n.º 6
0
def _build_alphaijk_binvars(cg: ComputationsFactorGraph,
                            agents_names: Iterable[str]):
    # As these variables are only used in the objective function,
    # when optimizing communication cost, we only need them when (i,j) is an
    # edge in the factor graph
    alphas = LpVariable.dict('a', ([(link.variable_node, link.factor_node)
                                    for link in cg.links], agents_names),
                             cat=LpBinary)
    return alphas
Ejemplo n.º 7
0
def _build_alphaijk_binvars(cg: ComputationConstraintsHyperGraph,
                            agents_names: Iterable[str]):
    # As these variables are only used in the objective function,
    # when optimizing communication cost, we only need them when (i,j) is an
    # edge in the factor graph
    edge_indexes = []
    for link in cg.links:
        for end1, end2 in combinations(link.nodes, 2):
            edge_indexes.append((end1, end2))

    alphas = LpVariable.dict("a", (edge_indexes, agents_names), cat=LpBinary)
    return alphas
Ejemplo n.º 8
0
def lp(numStates, numActions, end, rewards, probability, transitions,
       discount):
    problem = LpProblem("MDP", LpMinimize)
    values = LpVariable.dict("valueFunction", range(numStates))
    LpSolverDefault.msg = 0
    problem += lpSum([values[i] for i in range(numStates)])
    V = np.zeros((numStates, 1), dtype=LpVariable)
    for i in range(numStates):
        V[i][0] = values[i]
    for i in transitions:
        if i not in end:
            for j in transitions[i]:
                value = 0
                for trans in transitions[i][j]:
                    value += trans[2] * (trans[1] +
                                         discount * values[trans[0]])
                problem += (values[i] >= value)
    # additional constraint for episodic MDPs
    for i in end:
        problem += (values[i] == 0)
    # solve the linear programming problem
    problem.solve()
    newValues = np.zeros(numStates)
    for i in range(numStates):
        newValues[i] = values[i].varValue
    # getting the optimum policy

    actions = np.zeros(numStates)
    for i in transitions:
        if i not in end:
            maxValue = -float('inf')
            bestAction = 0
            for j in transitions[i]:
                value = 0
                for trans in transitions[i][j]:
                    value += trans[2] * (trans[1] +
                                         discount * newValues[trans[0]])
                if value > maxValue:
                    maxValue = value
                    bestAction = j
            actions[i] = bestAction
    return newValues, actions
Ejemplo n.º 9
0
def _theta_max(enengies, productions, co2s, energy_right, production_right, co2_right):
    '''
    _theta_max
    '''
    # the linear programming objective is maximize
    prob = LpProblem("theta_max", LpMaximize)
    variablecount = len(enengies)
    ingredients = [str(symbols + 1) for symbols in range(variablecount)]
    # the variable symbols  x1, x2, x3 .... xn
    symbols = LpVariable.dict('x_%s', ingredients, lowBound=0)
    cost = dict(zip(ingredients, productions))
    prob += lpSum([cost[i] * symbols[i] for i in ingredients])
    ene_dict = dict(zip(ingredients, enengies))
    co2_dict = dict(zip(ingredients, co2s))
    prob += lpSum([ene_dict[i] * symbols[i]
                   for i in ingredients]) <= energy_right
    prob += lpSum([co2_dict[i] * symbols[i] for i in ingredients]) == co2_right
    if prob.solve() != 1:
        raise UserWarning
    else:
        return prob.objective.value() / production_right
Ejemplo n.º 10
0
def _lambda_min(enengies, productions, co2s, energy_right, production_right, co2_right):
    '''
    _lambda_min
    '''
    # the linear programming objective is minimize
    prob = LpProblem("lambda_min", LpMinimize)
    variablecount = len(enengies)
    ingredients = [str(symbols + 1) for symbols in range(variablecount)]
    # variable symbols such x1, x2, x3 ... xn
    symbols = LpVariable.dict('x_%s', ingredients, lowBound=0)
    cost = dict(zip(ingredients, enengies))
    prob += lpSum([cost[i] * symbols[i] for i in ingredients])
    pro_dict = dict(zip(ingredients, productions))
    co2_dict = dict(zip(ingredients, co2s))
    # linear constraint condition
    prob += lpSum([pro_dict[i] * symbols[i]
                   for i in ingredients]) >= production_right
    prob += lpSum([co2_dict[i] * symbols[i] for i in ingredients]) == co2_right
    if prob.solve() != 1:
        raise UserWarning
    return prob.objective.value() / energy_right
Ejemplo n.º 11
0
product_manufactured: Dict = {0: "CP320", 1: "AF250"}
product_sales: Dict = {0: "CP320", 1: "AF250", 2: "clinker"}
components: Dict = {0: "clinker", 1: "slag", 2: "plaster", 3: "additive"}
composition: List = [[0.85, 0.50], [0.07, 0.45], [0.03, 0.03], [0.05, 0.02]]
limit_manufacture: int = 1100000
clinker_sales: int = 200000
slag_orders: int = 180000
plaster_orders: int = 50000
margin: List = [41.00, 37.80, 34.40]
slag_price: float = 22.10
plaster_price: float = 34.20
additive_price: float = 1.90

# Model and variables
model = LpProblem("Cement_production", LpMaximize)
var = LpVariable.dict("Product_sale", product_sales, lowBound=0, cat="Integer")

# Goal function
model += (lpSum(var[x] * margin[x] for x in product_sales) -
          slag_price * lpSum(
              (var[x] * composition[1][x]
               for x in product_manufactured)) - margin[2] * lpSum(
                   (var[x] * composition[2][x]
                    for x in product_manufactured)) - additive_price * lpSum(
                        (var[x] * composition[3][x]
                         for x in product_manufactured)))

# Constrains
model += var[2] <= clinker_sales
model += lpSum(var[x] for x in product_manufactured) <= limit_manufacture
model += (lpSum(composition[0][x] * var[x]
Ejemplo n.º 12
0
def ilp_cgdp(
    cg: ComputationGraph,
    agentsdef: Iterable[AgentDef],
    footprint: Callable[[str], float],
    capacity: Callable[[str], float],
    route: Callable[[str, str], float],
    msg_load: Callable[[str, str], float],
    hosting_cost: Callable[[str, str], float],
):
    agt_names = [a.name for a in agentsdef]
    pb = LpProblem("oilp_cgdp", LpMinimize)

    # One binary variable xij for each (variable, agent) couple
    xs = LpVariable.dict("x", (cg.node_names(), agt_names), cat=LpBinary)

    # TODO: Do not create var for computation that are already assigned to an agent with hosting = 0 ?
    # Force computation with hosting cost of 0 to be hosted on that agent.
    # This makes the work much easier for glpk !
    x_fixed_to_0 = []
    x_fixed_to_1 = []
    for agent in agentsdef:
        for comp in cg.node_names():
            assigned_agent = None
            if agent.hosting_cost(comp) == 0:
                pb += xs[(comp, agent.name)] == 1
                x_fixed_to_1.append((comp, agent.name))
                assigned_agent = agent.name
                for other_agent in agentsdef:
                    if other_agent.name == assigned_agent:
                        continue
                    pb += xs[(comp, other_agent.name)] == 0
                    x_fixed_to_0.append((comp, other_agent.name))
                logger.debug(
                    f"Setting binary varaibles to fixed computation {comp}")

    # One binary variable for computations c1 and c2, and agent a1 and a2
    betas = {}
    count = 0
    for a1, a2 in combinations(agt_names, 2):
        # Only create variables for couple c1, c2 if there is an edge in the
        # graph between these two computations.
        for l in cg.links:
            # As we support hypergraph, we may have more than 2 ends to a link
            for c1, c2 in combinations(l.nodes, 2):
                if (c1, a1, c2, a2) in betas:
                    continue
                count += 2
                b = LpVariable("b_{}_{}_{}_{}".format(c1, a1, c2, a2),
                               cat=LpBinary)
                betas[(c1, a1, c2, a2)] = b
                # Linearization constraints :
                # a_ijmn <= x_im
                # a_ijmn <= x_jn
                if (c1, a1) in x_fixed_to_0 or (c2, a2) in x_fixed_to_0:
                    pb += b == 0
                elif (c1, a1) in x_fixed_to_1:
                    pb += b == xs[(c2, a2)]
                elif (c2, a2) in x_fixed_to_1:
                    pb += b == xs[(c1, a1)]
                else:
                    pb += b <= xs[(c1, a1)]
                    pb += b <= xs[(c2, a2)]
                    pb += b >= xs[(c2, a2)] + xs[(c1, a1)] - 1

                b = LpVariable("b_{}_{}_{}_{}".format(c1, a2, c2, a1),
                               cat=LpBinary)
                if (c1, a2) in x_fixed_to_0 or (c2, a1) in x_fixed_to_0:
                    pb += b == 0
                elif (c1, a2) in x_fixed_to_1:
                    pb += b == xs[(c2, a1)]
                elif (c2, a1) in x_fixed_to_1:
                    pb += b == xs[(c1, a2)]
                else:
                    betas[(c1, a2, c2, a1)] = b
                    pb += b <= xs[(c2, a1)]
                    pb += b <= xs[(c1, a2)]
                    pb += b >= xs[(c1, a2)] + xs[(c2, a1)] - 1

    # Set objective: communication + hosting_cost
    pb += (
        _objective(xs, betas, route, msg_load, hosting_cost),
        "Communication costs and prefs",
    )

    # Adding constraints:
    # Constraints: Memory capacity for all agents.
    for a in agt_names:
        pb += (
            lpSum([footprint(i) * xs[i, a]
                   for i in cg.node_names()]) <= capacity(a),
            "Agent {} capacity".format(a),
        )

    # Constraints: all computations must be hosted.
    for c in cg.node_names():
        pb += (
            lpSum([xs[c, a] for a in agt_names]) == 1,
            "Computation {} hosted".format(c),
        )

    # solve using GLPK
    status = pb.solve(
        solver=GLPK_CMD(keepFiles=1, msg=False, options=["--pcost"]))

    if status != LpStatusOptimal:
        raise ImpossibleDistributionException("No possible optimal"
                                              " distribution ")
    logger.debug("GLPK cost : %s", pulp.value(pb.objective))

    mapping = {}
    for k in agt_names:
        agt_computations = [
            i for i, ka in xs if ka == k and pulp.value(xs[(i, ka)]) == 1
        ]
        # print(k, ' -> ', agt_computations)
        mapping[k] = agt_computations
    return mapping
Ejemplo n.º 13
0
from pulp import LpMinimize, LpProblem, LpStatus, LpVariable, lpSum, value

# Problem data
teams: List = [0, 1, 2, 3, 4]
jobs: List = [0, 1, 2, 3, 4]

costs: List = [
    [33, 22, 40, 21, 43],
    [27, 40, 55, 32, 26],
    [33, 38, 42, 49, 29],
    [36, 30, 52, 36, 34],
    [28, 45, 31, 42, 19],
]

# Decision variables
var = LpVariable.dict("x", (teams, jobs), cat="Binary")

# Model
model = LpProblem("Designation_problem", LpMinimize)

# Goal function
model += lpSum(var[x] * costs[x[0]][x[1]] for x in var.keys())

# Constrains
constrains_list: List = []

for time in teams:
    for job in jobs:
        constrains_list.append(var[(time, job)])
    model += lpSum(constrains_list) == 1
    constrains_list: List = []
Ejemplo n.º 14
0
    2: 3.4,
    3: 2,
    4: 3,
    5: 1.9,
    6: 0.6,
    7: 1,
    8: 2,
    9: 3
}

availabilities: Dict = {0: 4000, 1: 5000, 2: 3000, 3: 7000, 4: 2500}

total_volume: int = 1000

# Decision variable
var = LpVariable.dict("P", product, lowBound=0)

# Model
model = LpProblem("Manufacturing_problem_mix", LpMaximize)

# Goal function
model += lpSum(var[x] * profit[x] for x in product)

# Constrains
constrains_list: List = []

for i in availabilities.keys():
    for j in product:
        if cycle_time[j][i] != 0:
            constrains_list.append(var[j] * cycle_time[j][i])
        else:
Ejemplo n.º 15
0
from pulp import LpVariable, LpProblem, LpMinimize, LpStatus, lpSum, value

# Variaveis do Problema
times = [0, 1, 2, 3, 4]
obras = [0, 1, 2, 3, 4]

custos = [[33, 22, 40, 21, 43], [33, 40, 26, 17, 36], [34, 38, 42, 29, 39],
          [36, 30, 21, 36, 40], [28, 45, 31, 42, 19]]

# Variaveis de Decisao
var = LpVariable.dict("x", (times, obras), cat='Binary')

# criar problema
model = LpProblem('Problema_designacao', LpMinimize)

# Criar funcao objetivo
lista_fo = []

for x in var.keys():
    lista_fo.append(var[x] * custos[x[0]][x[1]])

model += lpSum(lista_fo)
print(model)

# Restricoes

lista_rest = []

for time in times:
    for obra in obras:
        lista_rest.append(var[(time, obra)])
Ejemplo n.º 16
0
def _build_xs_binvar(vars_to_host, agents_names):
    if not vars_to_host:
        return {}
    return LpVariable.dict("x", (vars_to_host, agents_names), cat=LpBinary)
Ejemplo n.º 17
0
import numpy as np
from pulp import LpMaximize, LpProblem, LpStatus, LpVariable, lpSum, value

# Problem Data
components: Dict = {0: "pure_gas", 1: "octane", 2: "additive"}
availabilities = np.array([9600000, 4800000, 2200000])
gas_types: Dict = {0: "green_gas", 1: "blue_gas", 2: "common_gas"}
composition: List = [[0.22, 0.50, 0.28], [0.52, 0.34, 0.14],
                     [0.74, 0.20, 0.06]]
contribution_margin = np.array([0.30, 0.25, 0.20])
limit_blue_gas: int = 600000
min_common_gas: int = 16  # times more than green gas

# Model and variables
model = LpProblem("Mix_gas", LpMaximize)
var = LpVariable.dict("GAS", gas_types, lowBound=0, cat="Integer")

model += lpSum(var[x] * contribution_margin[x] for x in gas_types)

# Constrains
model += (lpSum(var[0] * composition[0][0] + var[1] * composition[1][0] +
                var[2] * composition[2][0]) <= availabilities[0])
model += (lpSum(var[0] * composition[0][1] + var[1] * composition[1][1] +
                var[2] * composition[2][1]) <= availabilities[1])
model += (lpSum(var[0] * composition[0][2] + var[1] * composition[1][2] +
                var[2] * composition[2][2]) <= availabilities[2])

model += lpSum(min_common_gas * (var[0])) - lpSum(var[2]) <= 0
model += lpSum(var[1]) <= limit_blue_gas

print(model)
Ejemplo n.º 18
0
"""
Operational Research for allocation of Nexoos investments
"""

available_capital = 3000
investment = ['C2', 'C3', 'B6', 'B4']
min_invest = 1000
max_invest = 2000

interest = {'C2': 0.02235, 'C3': 0.02360, 'B6': 0.01808, 'B4': 0.01642}

risk = {'C2': 0.04, 'C3': 0.03, 'B6': 0.02, 'B4': 0.017}

# Decision variables
var = LpVariable.dict('Investment',
                      investment,
                      lowBound=min_invest,
                      upBound=max_invest)
#print(var)

model = LpProblem("Loan_allocation", LpMaximize)

# Objective Function
lista_fo = []

for x in var.keys():
    lista_fo.append(interest[x] * (1 - risk[x]) * var[x])

model += lpSum(lista_fo)

# Constrains
lista_rest = []
Ejemplo n.º 19
0
from pulp import LpVariable, LpProblem, LpMaximize, LpStatus,  lpSum, value

itens = ['A', 'B', 'C', 'D', 'E', 'F']

capacidade = 20000
peso = {'A': 7000, 'B': 4500, 'C': 8700, 'D': 8000, 'E': 4900, 'F': 7500}
valor = {'A': 36, 'B': 64, 'C': 40, 'D': 45, 'E': 60, 'F': 40}

# Variaveis de Decisao
var = LpVariable.dict("", itens, cat="Binary")

# Criar o Problema
model = LpProblem("Problema_Mochila01", LpMaximize)

# Funcao Objetivo
lista_fo = []

for item in itens:
    lista_fo.append(var[item] * valor[item])

model += lpSum(lista_fo)

# Restricoes
lista_rest = []

for item in itens:
    lista_rest.append(var[item] * peso[item])

model += lpSum(lista_rest) <= capacidade
print(model)
Ejemplo n.º 20
0
fixed_costs = np.array([
    300000,
    400000,
    490000,
])
variable_costs: object = (
    [40, 15, 20],
    [10, 12, 25],
    [30, 17, 27],
    [10, 12, 20],
)
annual_weeks: int = 52

# Model and variables
model = LpProblem("Terminal_location", LpMinimize)
var_1 = LpVariable.dict("Cities", cities, lowBound=0, cat="Binary")
var_2 = LpVariable.dict("Location", (terminals, cities),
                        lowBound=0,
                        cat="Integer")

# Goal function
model += lpSum(variable_costs[x][i] * var_2[(x, i)]
               for x, i in var_2) * annual_weeks + lpSum(
                   var_1[y] * fixed_costs[y] for y in cities)

# Constrains
for i in terminals:
    model += lpSum(var_2[(i, x)] for x in cities) == weekly_manufacture[i]

for x in cities:
    model += lpSum(var_2[(i, x)] for i in terminals) <= availabilities[x]
Ejemplo n.º 21
0
from pulp import LpVariable, LpProblem, LpMinimize, LpStatus,  lpSum, value

# Dados do problema

maquinas = [0, 1, 2]

custo_fixo = {0: 25, 1: 45, 2: 60}

custo_variavel = {0: 4, 1: 7, 2: 12}

capacidade = {0: 30, 1: 60, 2: 78}

# Variaveis de decisao

var = LpVariable.dict("x", (maquinas), cat="Integer", lowBound=0)
var2 = LpVariable.dict("y", (maquinas), cat="Binary")

# Criacao do Modelo

model = LpProblem("Problema_carga_fixa", LpMinimize)

# Criacao da funcao objetivo

lista_fo = []

for m in maquinas:
    lista_fo.append(var[m] * custo_variavel[m] + var2[m] * custo_fixo[m])

model += lpSum(lista_fo)
print(model)
Ejemplo n.º 22
0
def wildcard_suggestion(slim_elements_df, optimization_metric,
                        current_team_value, weight):
    fpl_problem = LpProblem('FPL', LpMaximize)
    optimization_df = slim_elements_df[[
        'id', 'second_name', 'team_name', 'team', 'total_points', 'position',
        'now_cost', 'ict_index', 'form'
    ]]
    optimization_df = optimization_df.join(
        pd.get_dummies(optimization_df['position']))
    players = optimization_df['second_name']
    optimization_df['now_cost'] = optimization_df['now_cost'] / 10
    x = LpVariable.dict('x_ % s',
                        players,
                        lowBound=0,
                        upBound=1,
                        cat=LpInteger)

    metric_data = []

    point_arr = np.array(optimization_df['total_points'])
    point_norm = np.linalg.norm(point_arr)
    point_arr = point_arr / point_norm
    clean_player_points = dict(
        zip(optimization_df.second_name,
            np.array(optimization_df['total_points'])))
    player_points = dict(zip(optimization_df.second_name, point_arr))

    ict_arr = np.array(optimization_df['total_points'])
    ict_norm = np.linalg.norm(ict_arr)
    ict_arr = ict_arr / ict_norm
    clean_player_ict = dict(
        zip(optimization_df.second_name,
            np.array(optimization_df['ict_index'])))
    player_ict = dict(zip(optimization_df.second_name, ict_arr))

    form_arr = np.array(optimization_df['form'])
    form_norm = np.linalg.norm(form_arr)
    form_arr = form_arr / form_norm
    clean_player_form = dict(
        zip(optimization_df.second_name, np.array(optimization_df['form'])))
    player_form = dict(zip(optimization_df.second_name, ict_arr))

    #to get player id
    clean_player_id = dict(
        zip(optimization_df.second_name, np.array(optimization_df['id'])))

    if 'total_points' in optimization_metric:
        metric_data.append(player_points)

    if 'ict_index' in optimization_metric:
        metric_data.append(player_ict)

    if 'form' in optimization_metric:
        metric_data.append(player_form)

    final_data = {}
    for i in range(len(metric_data)):
        if i == 0:
            m = 'total_points'
        elif i == 1:
            m = 'ict_index'
        else:
            m = 'form'
        d = metric_data[i]
        for player in d:
            if player in final_data:
                final_data[player] += weight[m] * d[player]
            else:
                final_data[player] = weight[m] * d[player]

    fpl_problem += sum(final_data[i] * x[i] for i in players)

    position_names = ['Goalkeeper', 'Defender', 'Midfielder', 'Forward']
    position_constraints = [2, 5, 5, 3]
    constraints = dict(zip(position_names, position_constraints))
    constraints['total_cost'] = float(current_team_value)
    constraints['team'] = 3

    player_cost = dict(
        zip(optimization_df.second_name, optimization_df.now_cost))
    player_position = dict(
        zip(optimization_df.second_name, optimization_df.position))
    player_gk = dict(
        zip(optimization_df.second_name, optimization_df.Goalkeeper))
    player_def = dict(
        zip(optimization_df.second_name, optimization_df.Defender))
    player_mid = dict(
        zip(optimization_df.second_name, optimization_df.Midfielder))
    player_fwd = dict(zip(optimization_df.second_name,
                          optimization_df.Forward))

    fpl_problem += sum([player_cost[i] * x[i]
                        for i in players]) <= float(constraints['total_cost'])
    fpl_problem += sum([player_gk[i] * x[i]
                        for i in players]) == constraints['Goalkeeper']
    fpl_problem += sum([player_def[i] * x[i]
                        for i in players]) == constraints['Defender']
    fpl_problem += sum([player_mid[i] * x[i]
                        for i in players]) == constraints['Midfielder']
    fpl_problem += sum([player_fwd[i] * x[i]
                        for i in players]) == constraints['Forward']

    for t in optimization_df.team.unique():
        optimization_df['team_' + str(t).lower()] = np.where(
            optimization_df.team == t, int(1), int(0))

    for t in optimization_df.team:
        player_team = dict(
            zip(optimization_df.second_name,
                optimization_df['team_' + str(t)]))
        fpl_problem += sum([player_team[i] * x[i]
                            for i in players]) <= constraints['team']

    fpl_problem.solve()

    total_points = 0.
    total_cost = 0.
    optimal_squad = []
    for p in players:
        if x[p].value() != 0:
            total_points += clean_player_points[p]
            total_cost += player_cost[p]

            optimal_squad.append({
                'name': p,
                'position': player_position[p],
                'cost': player_cost[p],
                'points': clean_player_points[p],
                'ict_index': clean_player_ict[p],
                'form': clean_player_form[p],
                'id': clean_player_id[p]
            })

    solution_info = {'total_points': total_points, 'total_cost': total_cost}
    optimal_squad_df = pd.DataFrame(optimal_squad)
    optimal_squad_df.sort_values('position', inplace=True)
    return optimal_squad_df, solution_info
Ejemplo n.º 23
0
from typing import Dict, List

from pulp import LpMinimize, LpProblem, LpStatus, LpVariable, lpSum, value

# Problem data
machines: List = [0, 1, 2]

fixed_cost: Dict = {0: 25, 1: 45, 2: 60}

variable_cost: Dict = {0: 4, 1: 7, 2: 12}

availability: Dict = {0: 30, 1: 60, 2: 78}

# Decision variables
var_1 = LpVariable.dict("X", machines, cat="Integer", lowBound=0)
var_2 = LpVariable.dict("Y", machines, cat="Binary")

# Model
model = LpProblem("fixed_load", LpMinimize)

# Goal function
model += lpSum(var_1[i] * variable_cost[i] + var_2[i] * fixed_cost[i]
               for i in machines)

# Constrains
for i in machines:
    model += var_1[i] <= availability[i] * var_2[i]

model += lpSum(x for x in var_1.values()) == 75

print(model)
Ejemplo n.º 24
0
from pulp import LpMaximize, LpProblem, LpStatus, LpVariable, lpSum, value

# Problem data
#           b1  b2 b3
reward: List = [
    [30, -10, -30],  # Very Hard A
    [0, -40, 10],  # Average A
    [-50, 60, 0],
]  # Light strategy A

strategy_A: List = [0, 1, 2]
strategy_B: List = [0, 1, 2]

# Decision variables
var = LpVariable.dict("A", strategy_A, lowBound=0)
v = LpVariable("v")

# Model
model = LpProblem("zero_sum_game", LpMaximize)

# Goal function
model += v

# Constrains
constrains_list: List = []

for j in strategy_B:
    for i in strategy_A:
        constrains_list.append(var[i] * reward[i][j])
    model += v - lpSum(constrains_list) == 0
Ejemplo n.º 25
0
#格子の数
SIZE = 10
#ばらまくPointの数
N = 3


#2点間の距離を算出する
def dist(p1, p2):
    return (sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) / SIZE)


######変数定義
#どこにPointを置くか
x = LpVariable.dict(name="x",
                    indexs=(range(SIZE), range(SIZE)),
                    lowBound=0,
                    upBound=1,
                    cat=LpBinary)
#今回のキモ 多目的のための変数(どんなに良くても対角の√2以下)
z = LpVariable("z", lowBound=0, upBound=1.5, cat=LpContinuous)

#問題定義
p = LpProblem(name="SpreadingPointsProblem", sense=LpMaximize)

#zの最大化問題として定義
p += z

#N個のPointが配置される
tmp_sub = 0
for i, j in product(range(SIZE), range(SIZE)):
    tmp_sub += x[(i, j)]
Ejemplo n.º 26
0
    1: 'Terminal_2',
    2: 'Terminal_3',
    3: 'Terminal_4'
}
manufacture = {0: 800, 1: 1200, 2: 650, 3: 1450}
variable_costs = [[40, 15, 20], [10, 12, 25], [30, 17, 27], [10, 12, 20]]

locations = {0: 'Niteroi', 1: 'Angra', 2: 'Campos'}
fixed_costs = {0: 300000, 1: 400000, 2: 490000}
availabilities = {0: 1500, 1: 2600, 2: 3400}

weeks = 52

# Objective Function

var_1 = LpVariable.dict('Cities', locations, cat='Binary')
var_2 = LpVariable.dict("Location", (terminals, locations),
                        lowBound=0,
                        cat='Integer')

objective_list = []

for i in var_1.keys():
    objective_list.append(var_1[i] * fixed_costs[i])

for x in var_2.keys():
    objective_list.append(weeks * (var_2[x] * variable_costs[x[0]][x[1]]))

objective_func += lpSum(objective_list)
# Constrains
Ejemplo n.º 27
0
def _build_fs_binvar(facs_to_host, agents_names):
    if not facs_to_host:
        return {}
    return LpVariable.dict("f", (facs_to_host, agents_names), cat=LpBinary)
Ejemplo n.º 28
0
# Problem Data
feed: List = [0, 1, 2, 3, 4, 5]

costs: Dict = {0: 0.74, 1: 0.70, 2: 0.83, 3: 0.81, 4: 0.73, 5: 0.75}

minimum: Dict = {0: 200, 1: 180, 2: 150}  # Carbohydrate  # Protein  # Vitamin

inf_nutri: List = [
    [50, 60, 30, 0, 20, 45],
    [27, 0, 40.5, 20, 30, 50],
    [50, 80, 60, 30, 20, 40],
]

# Model and Decision Variables
model = LpProblem("Diet_problem", LpMinimize)
var = LpVariable.dict("R", feed, lowBound=0, cat="Integer")

# Goal function
model += lpSum(var[x] * costs[x] for x in var.keys())

# Constrains
list_rest: List = []
for i in minimum.keys():
    for j in feed:
        list_rest.append(var[j] * inf_nutri[i][j])
    model += lpSum(list_rest) >= minimum[i]
    list_rest = []

print(model)

# Solving problem
Ejemplo n.º 29
0
passenger_capacity: Dict = {0: 50, 1: 30, 2: 20}
aircraft_availability: Dict = {0: 5, 1: 8, 2: 10}
route_demand: Dict = {0: 150, 1: 200, 2: 90, 3: 300}
total_travels: List = [[3, 2, 2, 1], [4, 3, 3, 2], [5, 5, 4, 2]]

operational_costs = [
    [1000, 1100, 1200, 1100],
    [800, 900, 1000, 1000],
    [600, 800, 800, 1000],
]

# Model and Decision Variables
model = LpProblem("Routing_problem", LpMinimize)
var = LpVariable.dict("aircraft", (aircraft_type, routes),
                      lowBound=0,
                      cat="Integer")

# Goal Function
model += lpSum(var[(x, y)] * operational_costs[x][y] for x, y in var.keys())

# Constrains
for y in route_demand.keys():
    """ Soma as capacidades das aeronaves nas rotas e limita em relacao a demanda """
    model += (lpSum(passenger_capacity[x] * var[(x, y)]
                    for x in passenger_capacity) >= route_demand[y])

for i in aircraft_type:
    """ Soma o numero de viagens/rota e restringe em relacao a disponibilidade de aeronaves """
    model += (lpSum(var[(i, y)] * (1 / total_travels[i][y])
                    for y in routes) <= aircraft_availability[i])
Ejemplo n.º 30
0
from pulp import LpVariable, LpProblem, LpMaximize, lpSum, LpStatus, value

# Dados do Problema

retornos = [[30, -10, -30], [0, -40, 10], [-50, 60, 0]]

estrategia_a = [0, 1, 2]
estrategia_b = [0, 1, 2]

# Criacao das variaveis de decisao

var = LpVariable.dict("A", (estrategia_a), lowBound=0)
v = LpVariable('v')

# Criacao do modelo

model = LpProblem("Jogo_soma_ZERO", LpMaximize)

# Criacao da funcao Objetivo

model += v

# Criacao das restricoes

lista_rest = []

for j in estrategia_b:
    for i in estrategia_a:
        lista_rest.append(var[i] * retornos[i][j])
    model += v - lpSum(lista_rest) == 0
    lista_rest = []