I am trying to make lists of names given certain input parameters of performance and want to look at the variance distribution but in my code I tend to get the same names over and over as high performers. Instead what I would like to be able to do is set a maximum exposure so that out of the 20 groups that I output, I can have a single person show up in say a maximum of 10 (50% exposure), 5 (25% exposure), etc. I am relatively new to Julia so any help would be greatly appreciated!

# Setting max exposure

**stillyslalom**#2

Please provide a minimum working example or a Gist of your code. Without an idea of what your code’s actually doing, it’s hard to provide useful help.

**dhislop**#3

```
using CSV
using DataFrames
using GLPKMathProgInterface
using JuMP
#=
Variables for solving the problem
=#
# num_lineups is the total number of lineups
num_lineups = 20
# num_overlap is the maximum overlap of players between the lineups that you create
num_overlap = 4
# num_exposure is the maximum number of times a player can be in a lineup
num_exposure = 10
# path_skaters is a string that gives the path to the csv file with the skaters information
path_skaters = "C:\\Users\\engja\\Desktop\\example_skaters.csv"
# path_goalies is a string that gives the path to the csv file with the goalies information
path_goalies = "C:\\Users\\engja\\Desktop\\example_goalies.csv"
# path_to_output is a string that gives the path to the csv file that will give the outputted results
path_to_output= "C:\\Users\\engja\\Desktop\\output.csv"
# This is a function that creates one lineup using No Stacking
function one_lineup_no_stacking(skaters, goalies, lineups, num_overlap, num_skaters, num_goalies, centers, wingers, defenders, num_teams, skaters_teams, goalie_opponents, team_lines, num_lines, P1_info)
m = Model(solver=GLPKSolverMIP())
# Variable for skaters in lineup.
@variable(m, skaters_lineup[i=1:num_skaters], Bin)
# Variable for goalie in lineup.
@variable(m, goalies_lineup[i=1:num_goalies], Bin)
# One goalie constraint
@constraint(m, sum(goalies_lineup[i] for i=1:num_goalies) == 1)
# Eight Skaters constraint
@constraint(m, sum(skaters_lineup[i] for i=1:num_skaters) == 8)
# Between 2 and 3 centers
@constraint(m, sum(centers[i]*skaters_lineup[i] for i=1:num_skaters) <= 3)
@constraint(m, 2 <= sum(centers[i]*skaters_lineup[i] for i=1:num_skaters))
# Between 3 and 4 wingers
@constraint(m, sum(wingers[i]*skaters_lineup[i] for i=1:num_skaters) <= 4)
@constraint(m, 3<=sum(wingers[i]*skaters_lineup[i] for i=1:num_skaters))
# Between 2 and 3 defenders
@constraint(m, 2 <= sum(defenders[i]*skaters_lineup[i] for i=1:num_skaters))
@constraint(m, sum(defenders[i]*skaters_lineup[i] for i=1:num_skaters) <= 3)
# Financial Constraint
@constraint(m, sum(skaters[i,:Salary]*skaters_lineup[i] for i=1:num_skaters) + sum(goalies[i,:Salary]*goalies_lineup[i] for i=1:num_goalies) <= 50000)
# At least 3 different teams for the 8 skaters constraints
@variable(m, used_team[i=1:num_teams], Bin)
@constraint(m, xyconstr[i=1:num_teams], used_team[i] <= sum(skaters_teams[t, i]*skaters_lineup[t] for t=1:num_skaters))
@constraint(m, sum(used_team[i] for i=1:num_teams) >= 3)
# Overlap Constraint
@constraint(m, xyconstr[i=1:size(lineups)[2]], sum(lineups[j,i]*skaters_lineup[j] for j=1:num_skaters) + sum(lineups[num_skaters+j,i]*goalies_lineup[j] for j=1:num_goalies) <= num_overlap)
# Exposure Constraint
@constraint(m, xyconstr[i=1....]..................................................................... <= num_exposure)
# Objective
@objective(m, Max, sum(skaters[i,:Projection]*skaters_lineup[i] for i=1:num_skaters) + sum(goalies[i,:Projection]*goalies_lineup[i] for i=1:num_goalies))
# Solve the integer programming problem
println("Solving Problem...")
@printf("\n")
status = solve(m);
# Puts the output of one lineup into a format that will be used later
if status==:Optimal
skaters_lineup_copy = Array{Int64}(0)
for i=1:num_skaters
if getvalue(skaters_lineup[i]) >= 0.9 && getvalue(skaters_lineup[i]) <= 1.1
skaters_lineup_copy = vcat(skaters_lineup_copy, fill(1,1))
else
skaters_lineup_copy = vcat(skaters_lineup_copy, fill(0,1))
end
end
for i=1:num_goalies
if getvalue(goalies_lineup[i]) >= 0.9 && getvalue(goalies_lineup[i]) <= 1.1
skaters_lineup_copy = vcat(skaters_lineup_copy, fill(1,1))
else
skaters_lineup_copy = vcat(skaters_lineup_copy, fill(0,1))
end
end
return(skaters_lineup_copy)
end
end
#=
formulation is the type of formulation that you would like to use
=#
formulation = one_lineup_No_Stacking
function create_lineups(num_lineups, num_overlap, path_skaters, path_goalies, formulation, path_to_output)
# Load information for skaters table
skaters = CSV.read(path_skaters)
# Load information for goalies table
goalies = CSV.read(path_goalies)
# Number of skaters
num_skaters = size(skaters)[1]
# Number of goalies
num_goalies = size(goalies)[1]
# wingers stores the information on which players are wings
wingers = Array{Int64}(0)
# centers stores the information on which players are centers
centers = Array{Int64}(0)
# defenders stores the information on which players are defenders
defenders = Array{Int64}(0)
#=
Process the position information in the skaters file to populate the wingers,
centers, and defenders with the corresponding correct information
=#
for i =1:num_skaters
if skaters[i,:Position] == "LW" || skaters[i,:Position] == "RW" || skaters[i,:Position] == "W"
wingers=vcat(wingers,fill(1,1))
centers=vcat(centers,fill(0,1))
defenders=vcat(defenders,fill(0,1))
elseif skaters[i,:Position] == "C"
wingers=vcat(wingers,fill(0,1))
centers=vcat(centers,fill(1,1))
defenders=vcat(defenders,fill(0,1))
elseif skaters[i,:Position] == "D" || skaters[i,:Position] == "LD" || skaters[i,:Position] == "RD"
wingers=vcat(wingers,fill(0,1))
centers=vcat(centers,fill(0,1))
defenders=vcat(defenders,fill(1,1))
else
wingers=vcat(wingers,fill(0,1))
centers=vcat(centers,fill(0,1))
defenders=vcat(defenders,fill(1,1))
end
end
# A forward is either a center or a winger
forwards = centers+wingers
# Create team indicators from the information in the skaters file
teams = unique(skaters[:Team])
# Total number of teams
num_teams = size(teams)[1]
# player_info stores information on which team each player is on
player_info = zeros(Int, num_teams)
# Populate player_info with the corresponding information
for j=1:size(teams)[1]
if skaters[1, :Team] == teams[j]
player_info[j] =1
end
end
skaters_teams = player_info'
for i=2:num_skaters
player_info = zeros(Int, size(teams)[1])
for j=1:size(teams)[1]
if skaters[i, :Team] == teams[j]
player_info[j] =1
end
end
skaters_teams = vcat(skaters_teams, player_info')
end
# Create goalie identifiers so you know who they are playing
opponents = goalies[:Opponent]
goalie_teams = goalies[:Team]
goalie_opponents=[]
for num = 1:size(teams)[1]
if opponents[1] == teams[num]
goalie_opponents = skaters_teams[:, num]
end
end
for num = 2:size(opponents)[1]
for num_2 = 1:size(teams)[1]
if opponents[num] == teams[num_2]
goalie_opponents = hcat(goalie_opponents, skaters_teams[:,num_2])
end
end
end
# Create line indicators so you know which players are on which lines
L1_info = zeros(Int, num_skaters)
L2_info = zeros(Int, num_skaters)
L3_info = zeros(Int, num_skaters)
L4_info = zeros(Int, num_skaters)
for num=1:size(skaters)[1]
if skaters[:Team][num] == teams[1]
if skaters[:Line][num] == "1"
L1_info[num] = 1
elseif skaters[:Line][num] == "2"
L2_info[num] = 1
elseif skaters[:Line][num] == "3"
L3_info[num] = 1
elseif skaters[:Line][num] == "4"
L4_info[num] = 1
end
end
end
team_lines = hcat(L1_info, L2_info, L3_info, L4_info)
for num2 = 2:size(teams)[1]
L1_info = zeros(Int, num_skaters)
L2_info = zeros(Int, num_skaters)
L3_info = zeros(Int, num_skaters)
L4_info = zeros(Int, num_skaters)
for num=1:size(skaters)[1]
if skaters[:Team][num] == teams[num2]
if skaters[:Line][num] == "1"
L1_info[num] = 1
elseif skaters[:Line][num] == "2"
L2_info[num] = 1
elseif skaters[:Line][num] == "3"
L3_info[num] = 1
elseif skaters[:Line][num] == "4"
L4_info[num] = 1
end
end
end
team_lines = hcat(team_lines, L1_info, L2_info, L3_info, L4_info)
end
num_lines = size(team_lines)[2]
# Create power play indicators
PP_info = zeros(Int, num_skaters)
for num=1:size(skaters)[1]
if skaters[:Team][num]==teams[1]
if skaters[:Power_Play][num] == "1"
PP_info[num] = 1
end
end
end
P1_info = PP_info
for num2=2:size(teams)[1]
PP_info = zeros(Int, num_skaters)
for num=1:size(skaters)[1]
if skaters[:Team][num] == teams[num2]
if skaters[:Power_Play][num] == "1"
PP_info[num]=1
end
end
end
P1_info = hcat(P1_info, PP_info)
end
# Lineups using formulation as the stacking type
the_lineup= formulation(skaters, goalies, hcat(zeros(Int, num_skaters + num_goalies), zeros(Int, num_skaters + num_goalies)), num_overlap, num_skaters, num_goalies, centers, wingers, defenders, num_teams, skaters_teams, goalie_opponents, team_lines, num_lines, P1_info)
the_lineup2 = formulation(skaters, goalies, hcat(the_lineup, zeros(Int, num_skaters + num_goalies)), num_overlap, num_skaters, num_goalies, centers, wingers, defenders, num_teams, skaters_teams, goalie_opponents, team_lines, num_lines, P1_info)
tracer = hcat(the_lineup, the_lineup2)
for i=1:(num_lineups-2)
try
thelineup=formulation(skaters, goalies, tracer, num_overlap, num_skaters, num_goalies, centers, wingers, defenders, num_teams, skaters_teams, goalie_opponents, team_lines, num_lines, P1_info)
tracer = hcat(tracer,thelineup)
catch
break
end
end
# Create the output csv file
lineup2 = ""
for j = 1:size(tracer)[2]
lineup = ["" "" "" "" "" "" "" "" ""]
for i =1:num_skaters
if tracer[i,j] == 1
if centers[i]==1
if lineup[1]==""
lineup[1] = string(skaters[i,1])
elseif lineup[2]==""
lineup[2] = string(skaters[i,1])
elseif lineup[9] ==""
lineup[9] = string(skaters[i,1])
end
elseif wingers[i] == 1
if lineup[3] == ""
lineup[3] = string(skaters[i,1])
elseif lineup[4] == ""
lineup[4] = string(skaters[i,1])
elseif lineup[5] == ""
lineup[5] = string(skaters[i,1])
elseif lineup[9] == ""
lineup[9] = string(skaters[i,1])
end
elseif defenders[i]==1
if lineup[6] == ""
lineup[6] = string(skaters[i,1])
elseif lineup[7] ==""
lineup[7] = string(skaters[i,1])
elseif lineup[9] == ""
lineup[9] = string(skaters[i,1])
end
end
end
end
for i =1:num_goalies
if tracer[num_skaters+i,j] == 1
lineup[8] = string(goalies[i,1])
end
end
for name in lineup
lineup2 = string(lineup2, name, ",")
end
lineup2 = chop(lineup2)
lineup2 = string(lineup2, """
""")
end
outfile = open(path_to_output, "w")
write(outfile, lineup2)
close(outfile)
end
# Running the code
create_lineups(num_lineups, num_overlap, path_skaters, path_goalies, formulation, path_to_output)
```

**dhislop**#4

I pasted the code that I am trying to use. I added in a variable to control max exposure and added in a constraint, I just don’t know exactly how to structure the constraint in the body of the code.