#### Simplex Standard

G
```{
"cells": [
{
"cell_type": "markdown",
"source": [
"This is a notebook to solve linear programming problem using the simmplex method. The inputs are supplied in the form of standard LPP that is the objective shooulf be of maximization type and all the constraints should be of <= type.\n",
"Example being:\n",
"\n",
"maximize z: 3*x1 + 4*x2\n",
"\n",
"      s.t.: 5*x1+ 4*x2<=15\n",
"      ...\n",
"      \n",
"Here a sample problem is solved:\n",
"Maximize\tP\t=\t20x1\t+\t10x2\t+\t15x3\t\n",
"\n",
"\n",
"Subject to: \n",
"\n",
"3x1\t+\t2x2\t+\t5x3\t≤\t55\n",
"\n",
"2x1\t+\tx2\t+\tx3\t≤\t26\n",
"\n",
"x1\t+\tx2\t+\t3x3\t≤\t30\n",
"\n",
"5x1\t+\t2x2\t+\t4x3\t≤\t57\n",
"\n",
"x1\t,\tx2\t,\tx3\t≥\t0\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"outputs": [],
"source": [
"import numpy as np"
]
},
{
"cell_type": "markdown",
"source": [
"# Enter data for the simplex:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"outputs": [],
"source": [
"num_vars = None # 3 here\n",
"cost_vector = None #[20 10 15]\n",
"num_consts = None # 4\n",
"A = None #[[3 2 5],[2 1 1], [1 1 3],[5 2 4]]\n",
"b = None #[55 26 30 57]"
]
},
{
"cell_type": "code",
"execution_count": 3,
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Enter the Linear programming data in standard form: \n",
"Number of variables: 3\n",
"Coefficients of the decision variables in cost function: 20 10 15\n",
"Number of constraints: 4\n",
"Inequality constraints data: \n",
"Enter the matrix of coefficients: \n",
"Constraint: 1\n",
"Coefficients: 3 2 5\n",
"Constraint: 2\n",
"Coefficients: 2 1 1\n",
"Constraint: 3\n",
"Coefficients: 1 1 3\n",
"Constraint: 4\n",
"Coefficients: 5 2 4\n",
"Enter the RHS: 55 26 30 57\n"
]
}
],
"source": [
"print(\"Enter the Linear programming data in standard form: \")\n",
"num_vars = int(input('Number of variables: '))\n",
"\n",
"cost_vector = input('Coefficients of the decision variables in cost function: ')\n",
"cost_vector = cost_vector.split(' ')\n",
"cost_vector = [int(i) for i in cost_vector]\n",
"cost_vector = np.array(cost_vector)\n",
"\n",
"num_consts = int(input('Number of constraints: '))\n",
"print(\"Inequality constraints data: \")\n",
"\n",
"print('Enter the matrix of coefficients: ')\n",
"\n",
"A = np.zeros((num_consts,num_vars))\n",
"\n",
"for i in range(num_consts):\n",
"    print(\"Constraint: \"+str(i+1))\n",
"    x = input(\"Coefficients: \")\n",
"    x = x.split(' ')\n",
"    x = [float(k) for k in x]\n",
"    for j in range(num_vars):\n",
"        A[i][j] = x[j]\n",
"\n",
"\n",
"b = input(\"Enter the RHS: \")\n",
"b = b.split(' ')\n",
"b = [float(k) for k in b]"
]
},
{
"cell_type": "code",
"execution_count": 4,
"outputs": [],
"source": [
"A_ = A.copy()\n",
"b_ = b.copy()"
]
},
{
"cell_type": "markdown",
"source": [
"# Enter again from here on the same data:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"outputs": [],
"source": [
"A = A_.copy()\n",
"b = b_.copy()"
]
},
{
"cell_type": "code",
"execution_count": 6,
"outputs": [],
"source": [
"num_le = num_consts\n",
"num_eq = 0\n",
"num_ge = 0\n",
"\n",
"\n",
"\n",
"v_slack = []\n",
"A_slacks = np.zeros((num_consts,num_consts))\n",
"v_artificial = []\n",
"A_surplus = np.zeros((num_consts,num_ge))\n",
"v_bounds = []\n",
"\n",
"\n",
"\n",
"for i in  range(num_consts):\n",
"    s = '<='\n",
"\n",
"    if s=='<=':\n",
"        v_slack.append(b[i])\n",
"        A_slacks[i][len(v_slack)-1] = 1\n",
"    elif s=='>=':\n",
"        v_slack.append(0)\n",
"        A_slacks[i][len(v_slack)-1] = -1\n",
"        v_artificial.append(b[i])\n",
"        A_surplus[i][len(v_artificial)-1] = 1\n",
"    else:\n",
"        v_artificial.append(b[i])\n",
"        A_surplus[i][len(v_artificial)-1] = 1\n",
"    \n",
"    v_bounds.append(b[i])\n",
"\n",
"\n",
"A = np.hstack([A,A_slacks,A_surplus])\n",
"\n",
"vari = []\n",
"vari_ar = []\n",
"vari_slack = []\n",
"vari_nb = []\n",
"\n",
"variables = []\n",
"for i in  range(len(A)):\n",
"    variables.append('x'+str(i+1))\n",
"    vari.append('x'+str(i+1))\n",
"    if i < num_vars:\n",
"        vari_nb.append('x'+str(i+1))\n",
"    elif i< num_vars + len(v_slack):\n",
"        vari_slack.append('x'+str(i+1))\n",
"    else:\n",
"        vari_ar.append('x'+str(i+1))\n",
"\n",
"all_vars = {}"
]
},
{
"cell_type": "code",
"execution_count": 7,
"outputs": [],
"source": [
"v_a = 0*cost_vector\n",
"v_ar = None\n",
"\n",
"x = np.hstack([v_a,v_slack,v_artificial])\n",
"\n",
"for v,val in zip(variables,x):\n",
"    all_vars[v] = val\n",
"\n",
"\n",
"if len(v_artificial)==0:\n",
"    v_ar = []\n",
"else:\n",
"    if type_problem == 1:\n",
"        v_ar = -9999*np.ones(len(v_artificial))\n",
"    else:\n",
"        v_ar = 9999*np.ones(len(v_artificial))\n",
"\n",
"Cj = np.hstack([cost_vector,0*np.array(v_slack),v_ar])\n",
"Ci = []\n",
"tab1 = []\n",
"Vb = []\n",
"Q = v_bounds\n",
"\n",
"struct2_curr_values = np.zeros(len(Q))\n",
"struct2_var_base = ['' for _ in range(len(Q))]\n",
"\n",
"for i in range(len(Q)):\n",
"    tab1.append('|')\n",
"    struct2_curr_values = Q[i]\n",
"    ind = np.where(x==Q[i])\n",
"    ind = ind\n",
"    ind = ind\n",
"\n",
"    struct2_var_base[i] = variables[ind]\n",
"    Vb.append(struct2_var_base[i])\n",
"    Ci.append(Cj[ind])"
]
},
{
"cell_type": "code",
"execution_count": 8,
"outputs": [],
"source": [
"Ci = np.array(Ci)\n",
"\n",
"Z = sum(np.multiply(Ci,Q))\n",
"Zj = np.zeros(len(Cj))\n",
"\n",
"for i in range(len(Cj)):\n",
"    Zj[i] = sum(np.multiply(Ci,A[:,i])) \n",
"vars_at_moment = struct2_var_base.copy()"
]
},
{
"cell_type": "code",
"execution_count": 9,
"outputs": [],
"source": [
"def get_row(vec):\n",
"    k = ''\n",
"    for i in vec:\n",
"        k+= '{0:>10}'.format(round(i,3))\n",
"    return k"
]
},
{
"cell_type": "code",
"execution_count": 10,
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"=========LP in standard form:=========\n",
"variables:  ['x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7']\n",
"Activity variables:  ['x1', 'x2', 'x3']\n",
"Slack variables:  ['x4', 'x5', 'x6', 'x7']\n",
"Artificial variables:  []\n",
"======Iteration: 0======\n",
"Initializing variables:  ['x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7']\n",
"Activity variables:  [0.0, 0.0, 0.0]\n",
"Slack variables:  ['x4', 'x5', 'x6', 'x7'] [55.0, 26.0, 30.0, 57.0]\n",
"Artificial variables:  []\n",
"=======================================================================================================\n",
"Variables:                                        1         2         3         4         5         6         7\n",
"Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0\n",
"Basic        |Value       |RHS\n",
"|         x4 |        0.0 |       55.0 |        3.0       2.0       5.0       1.0       0.0       0.0       0.0 |\n",
"|         x5 |        0.0 |       26.0 |        2.0       1.0       1.0       0.0       1.0       0.0       0.0 |\n",
"|         x6 |        0.0 |       30.0 |        1.0       1.0       3.0       0.0       0.0       1.0       0.0 |\n",
"|         x7 |        0.0 |       57.0 |        5.0       2.0       4.0       0.0       0.0       0.0       1.0 |\n",
"=======================================================================================================\n",
"Zj:                                             0.0       0.0       0.0       0.0       0.0       0.0       0.0\n",
"Cj-Zj:                                         20.0      10.0      15.0       0.0       0.0       0.0       0.0\n",
"Z:  0.0\n"
]
}
],
"source": [
"print(\"=========LP in standard form:=========\")\n",
"\n",
"print(\"variables: \",vari)\n",
"print(\"Activity variables: \",vari_nb)\n",
"print(\"Slack variables: \",vari_slack)\n",
"print(\"Artificial variables: \",vari_ar)\n",
"\n",
"print(\"======Iteration: 0======\")\n",
"print(\"Initializing variables: \",vari)\n",
"print(\"Activity variables: \",[all_vars[v] for v in vari_nb])\n",
"print(\"Slack variables: \",vari_slack,[all_vars[v] for v in vari_slack])\n",
"print(\"Artificial variables: \",v_ar)\n",
"print('=======================================================================================================')\n",
"print(\"Variables:                              \",get_row(np.arange(start=1,stop=len(A[0,:])+1,step = 1 )))\n",
"print(\"Cj:                                     \",get_row(Cj))\n",
"print(\"Basic        |Value       |RHS\")\n",
"for i in range(num_consts):\n",
"    print('|',\"{0:>10}\".format(vars_at_moment[i]),'|',\"{0:>10}\".format(Ci[i]),'|',\"{0:>10}\".format(round(Q[i],3)),'|',get_row(A[i]),'|')\n",
"\n",
"print('=======================================================================================================')\n",
"print('Zj:                                     ',get_row(Zj))\n",
"print('Cj-Zj:                                  ',get_row(Cj-Zj))\n",
"print('Z: ',round(Z,3))"
]
},
{
"cell_type": "code",
"execution_count": 11,
"outputs": [],
"source": [
"iterNum = 1"
]
},
{
"cell_type": "code",
"execution_count": 12,
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"=====Iteration 2 =======\n",
"Enter:  x1\n",
"Leave:  x7\n",
"Pivot:  5.0\n",
"========\n",
"=======================================================================================================\n",
"Variables:                                        1         2         3         4         5         6         7\n",
"Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0\n",
"Basic        |Value       |RHS\n",
"|         x4 |        0.0 |       20.8 |        0.0       0.8       2.6       1.0       0.0       0.0      -0.6 |\n",
"|         x5 |        0.0 |        3.2 |        0.0       0.2      -0.6       0.0       1.0       0.0      -0.4 |\n",
"|         x6 |        0.0 |       18.6 |        0.0       0.6       2.2       0.0       0.0       1.0      -0.2 |\n",
"|         x1 |       20.0 |       11.4 |        1.0       0.4       0.8       0.0       0.0       0.0       0.2 |\n",
"=======================================================================================================\n",
"Zj:                                            20.0       8.0      16.0       0.0       0.0       0.0       4.0\n",
"Cj-Zj:                                          0.0       2.0      -1.0       0.0       0.0       0.0      -4.0\n",
"Z:  228.0\n",
"=====Iteration 3 =======\n",
"Enter:  x2\n",
"Leave:  x5\n",
"Pivot:  0.2\n",
"========\n",
"=======================================================================================================\n",
"Variables:                                        1         2         3         4         5         6         7\n",
"Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0\n",
"Basic        |Value       |RHS\n",
"|         x4 |        0.0 |        8.0 |        0.0       0.0       5.0       1.0      -4.0       0.0       1.0 |\n",
"|         x2 |       10.0 |       16.0 |        0.0       1.0      -3.0       0.0       5.0       0.0      -2.0 |\n",
"|         x6 |        0.0 |        9.0 |        0.0       0.0       4.0       0.0      -3.0       1.0       1.0 |\n",
"|         x1 |       20.0 |        5.0 |        1.0       0.0       2.0       0.0      -2.0       0.0       1.0 |\n",
"=======================================================================================================\n",
"Zj:                                            20.0      10.0      10.0       0.0      10.0       0.0       0.0\n",
"Cj-Zj:                                          0.0       0.0       5.0       0.0     -10.0       0.0       0.0\n",
"Z:  260.0\n",
"=====Iteration 4 =======\n",
"Enter:  x3\n",
"Leave:  x4\n",
"Pivot:  5.0\n",
"========\n",
"=======================================================================================================\n",
"Variables:                                        1         2         3         4         5         6         7\n",
"Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0\n",
"Basic        |Value       |RHS\n",
"|         x3 |       15.0 |        1.6 |        0.0       0.0       1.0       0.2      -0.8       0.0       0.2 |\n",
"|         x2 |       10.0 |       20.8 |        0.0       1.0       0.0       0.6       2.6       0.0      -1.4 |\n",
"|         x6 |        0.0 |        2.6 |        0.0       0.0       0.0      -0.8       0.2       1.0       0.2 |\n",
"|         x1 |       20.0 |        1.8 |        1.0       0.0       0.0      -0.4      -0.4       0.0       0.6 |\n",
"=======================================================================================================\n",
"Zj:                                            20.0      10.0      15.0       1.0       6.0       0.0       1.0\n",
"Cj-Zj:                                          0.0       0.0       0.0      -1.0      -6.0       0.0      -1.0\n",
"Z:  268.0\n"
]
}
],
"source": [
"\n",
"while iterNum<=10:\n",
"    iterNum+=1\n",
"    type_problem = 1\n",
"    if type_problem == 1:\n",
"        num = max(Cj-Zj)\n",
"        index = np.where((Cj-Zj)==num)\n",
"        index = index\n",
"        v_enter = variables[index]\n",
"    else:\n",
"        num = min(Cj-Zj)\n",
"        index = np.where((Cj-Zj)==num)\n",
"        index = index\n",
"        v_enter = variables[index]\n",
"    \n",
"    b = A[:,index]\n",
"    k = -1\n",
"    d = 10000\n",
"    \n",
"    for i in range(len(Q)):\n",
"        if b[i]>0:\n",
"            div = Q[i]/b[i]\n",
"            if d>=div:\n",
"                d = div\n",
"                k = i\n",
"    if k == -1:\n",
"        print('Solution is infinty ')\n",
"        break\n",
"    else:\n",
"        num2 = k\n",
"    \n",
"    v_leave = struct2_var_base[num2]\n",
"    struct2_var_base[num2] = v_enter\n",
"    pivot = A[num2,index]\n",
"    Ci[num2] = Cj[index]\n",
"    A[num2,:] = A[num2,:]/pivot\n",
"    Q[num2] = Q[num2]/pivot\n",
"    \n",
"    #Row operations:\n",
"    \n",
"    for i in range(num_consts):\n",
"        \n",
"        if i!= num2:\n",
"            Q[i] = Q[i] - A[i,index]*Q[num2]\n",
"            A[i,:] = A[i,:] - A[i,index]*A[num2,:]\n",
"    Z = sum(np.multiply(Ci,Q))\n",
"    for i in  range(len(A[0,:])):\n",
"        Zj[i] = sum(np.multiply(A[:,i],Ci))\n",
"    \n",
"    vars_at_moment = []\n",
"    for i in range(num_consts):\n",
"        vars_at_moment.append(struct2_var_base[i])\n",
"    \n",
"    print('=====Iteration',iterNum,'=======')\n",
"    print('Enter: ',v_enter)\n",
"    print('Leave: ',v_leave)\n",
"    print('Pivot: ',round(pivot,3))\n",
"    \n",
"    print('========')\n",
"\n",
"    print('=======================================================================================================')\n",
"    print(\"Variables:                              \",get_row(np.arange(start=1,stop=len(A[0,:])+1,step = 1 )))\n",
"    print(\"Cj:                                     \",get_row(Cj))\n",
"    print(\"Basic        |Value       |RHS\")\n",
"    for i in range(num_consts):\n",
"        print('|',\"{0:>10}\".format(vars_at_moment[i]),'|',\"{0:>10}\".format(Ci[i]),'|',\"{0:>10}\".format(round(Q[i],3)),'|',get_row(A[i]),'|')\n",
"\n",
"    print('=======================================================================================================')\n",
"    print('Zj:                                     ',get_row(Zj))\n",
"    print('Cj-Zj:                                  ',get_row(Cj-Zj))\n",
"    print('Z: ',round(Z,3))\n",
"    if type_problem ==1:\n",
"        temp = max(Cj-Zj)\n",
"        if temp<=0:\n",
"            break\n",
"    else:\n",
"        temp = min(Cj-Zj)\n",
"        if temp>=0:\n",
"            break\n",
"    "
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": []
}
],
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
```

This is a notebook to solve linear programming problem using the simmplex method. The inputs are supplied in the form of standard LPP that is the objective shooulf be of maximization type and all the constraints should be of <= type. Example being:

maximize z: 3x1 + 4x2

``````  s.t.: 5*x1+ 4*x2<=15
...

``````

Here a sample problem is solved: Maximize P = 20x1 + 10x2 + 15x3

Subject to:

3x1 + 2x2 + 5x3 ≤ 55

2x1 + x2 + x3 ≤ 26

x1 + x2 + 3x3 ≤ 30

5x1 + 2x2 + 4x3 ≤ 57

x1 , x2 , x3 ≥ 0

``import numpy as np``

# Enter data for the simplex:

``````num_vars = None # 3 here
cost_vector = None #[20 10 15]
num_consts = None # 4
A = None #[[3 2 5],[2 1 1], [1 1 3],[5 2 4]]
b = None #[55 26 30 57]``````
``````print("Enter the Linear programming data in standard form: ")
num_vars = int(input('Number of variables: '))

cost_vector = input('Coefficients of the decision variables in cost function: ')
cost_vector = cost_vector.split(' ')
cost_vector = [int(i) for i in cost_vector]
cost_vector = np.array(cost_vector)

num_consts = int(input('Number of constraints: '))
print("Inequality constraints data: ")

print('Enter the matrix of coefficients: ')

A = np.zeros((num_consts,num_vars))

for i in range(num_consts):
print("Constraint: "+str(i+1))
x = input("Coefficients: ")
x = x.split(' ')
x = [float(k) for k in x]
for j in range(num_vars):
A[i][j] = x[j]

b = input("Enter the RHS: ")
b = b.split(' ')
b = [float(k) for k in b]``````
```Enter the Linear programming data in standard form:
Number of variables: 3
Coefficients of the decision variables in cost function: 20 10 15
Number of constraints: 4
Inequality constraints data:
Enter the matrix of coefficients:
Constraint: 1
Coefficients: 3 2 5
Constraint: 2
Coefficients: 2 1 1
Constraint: 3
Coefficients: 1 1 3
Constraint: 4
Coefficients: 5 2 4
Enter the RHS: 55 26 30 57
```
``````A_ = A.copy()
b_ = b.copy()``````

# Enter again from here on the same data:

``````A = A_.copy()
b = b_.copy()``````
``````num_le = num_consts
num_eq = 0
num_ge = 0

v_slack = []
A_slacks = np.zeros((num_consts,num_consts))
v_artificial = []
A_surplus = np.zeros((num_consts,num_ge))
v_bounds = []

for i in  range(num_consts):
s = '&lt;='

if s=='&lt;=':
v_slack.append(b[i])
A_slacks[i][len(v_slack)-1] = 1
elif s=='&gt;=':
v_slack.append(0)
A_slacks[i][len(v_slack)-1] = -1
v_artificial.append(b[i])
A_surplus[i][len(v_artificial)-1] = 1
else:
v_artificial.append(b[i])
A_surplus[i][len(v_artificial)-1] = 1

v_bounds.append(b[i])

A = np.hstack([A,A_slacks,A_surplus])

vari = []
vari_ar = []
vari_slack = []
vari_nb = []

variables = []
for i in  range(len(A)):
variables.append('x'+str(i+1))
vari.append('x'+str(i+1))
if i &lt; num_vars:
vari_nb.append('x'+str(i+1))
elif i&lt; num_vars + len(v_slack):
vari_slack.append('x'+str(i+1))
else:
vari_ar.append('x'+str(i+1))

all_vars = {}``````
``````v_a = 0*cost_vector
v_ar = None

x = np.hstack([v_a,v_slack,v_artificial])

for v,val in zip(variables,x):
all_vars[v] = val

if len(v_artificial)==0:
v_ar = []
else:
if type_problem == 1:
v_ar = -9999*np.ones(len(v_artificial))
else:
v_ar = 9999*np.ones(len(v_artificial))

Cj = np.hstack([cost_vector,0*np.array(v_slack),v_ar])
Ci = []
tab1 = []
Vb = []
Q = v_bounds

struct2_curr_values = np.zeros(len(Q))
struct2_var_base = ['' for _ in range(len(Q))]

for i in range(len(Q)):
tab1.append('|')
struct2_curr_values = Q[i]
ind = np.where(x==Q[i])
ind = ind
ind = ind

struct2_var_base[i] = variables[ind]
Vb.append(struct2_var_base[i])
Ci.append(Cj[ind])``````
``````Ci = np.array(Ci)

Z = sum(np.multiply(Ci,Q))
Zj = np.zeros(len(Cj))

for i in range(len(Cj)):
Zj[i] = sum(np.multiply(Ci,A[:,i]))
vars_at_moment = struct2_var_base.copy()``````
``````def get_row(vec):
k = ''
for i in vec:
k+= '{0:&gt;10}'.format(round(i,3))
return k``````
``````print("=========LP in standard form:=========")

print("variables: ",vari)
print("Activity variables: ",vari_nb)
print("Slack variables: ",vari_slack)
print("Artificial variables: ",vari_ar)

print("======Iteration: 0======")
print("Initializing variables: ",vari)
print("Activity variables: ",[all_vars[v] for v in vari_nb])
print("Slack variables: ",vari_slack,[all_vars[v] for v in vari_slack])
print("Artificial variables: ",v_ar)
print('=======================================================================================================')
print("Variables:                              ",get_row(np.arange(start=1,stop=len(A[0,:])+1,step = 1 )))
print("Cj:                                     ",get_row(Cj))
print("Basic        |Value       |RHS")
for i in range(num_consts):
print('|',"{0:&gt;10}".format(vars_at_moment[i]),'|',"{0:&gt;10}".format(Ci[i]),'|',"{0:&gt;10}".format(round(Q[i],3)),'|',get_row(A[i]),'|')

print('=======================================================================================================')
print('Zj:                                     ',get_row(Zj))
print('Cj-Zj:                                  ',get_row(Cj-Zj))
print('Z: ',round(Z,3))``````
```=========LP in standard form:=========
variables:  [&#x27;x1&#x27;, &#x27;x2&#x27;, &#x27;x3&#x27;, &#x27;x4&#x27;, &#x27;x5&#x27;, &#x27;x6&#x27;, &#x27;x7&#x27;]
Activity variables:  [&#x27;x1&#x27;, &#x27;x2&#x27;, &#x27;x3&#x27;]
Slack variables:  [&#x27;x4&#x27;, &#x27;x5&#x27;, &#x27;x6&#x27;, &#x27;x7&#x27;]
Artificial variables:  []
======Iteration: 0======
Initializing variables:  [&#x27;x1&#x27;, &#x27;x2&#x27;, &#x27;x3&#x27;, &#x27;x4&#x27;, &#x27;x5&#x27;, &#x27;x6&#x27;, &#x27;x7&#x27;]
Activity variables:  [0.0, 0.0, 0.0]
Slack variables:  [&#x27;x4&#x27;, &#x27;x5&#x27;, &#x27;x6&#x27;, &#x27;x7&#x27;] [55.0, 26.0, 30.0, 57.0]
Artificial variables:  []
=======================================================================================================
Variables:                                        1         2         3         4         5         6         7
Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0
Basic        |Value       |RHS
|         x4 |        0.0 |       55.0 |        3.0       2.0       5.0       1.0       0.0       0.0       0.0 |
|         x5 |        0.0 |       26.0 |        2.0       1.0       1.0       0.0       1.0       0.0       0.0 |
|         x6 |        0.0 |       30.0 |        1.0       1.0       3.0       0.0       0.0       1.0       0.0 |
|         x7 |        0.0 |       57.0 |        5.0       2.0       4.0       0.0       0.0       0.0       1.0 |
=======================================================================================================
Zj:                                             0.0       0.0       0.0       0.0       0.0       0.0       0.0
Cj-Zj:                                         20.0      10.0      15.0       0.0       0.0       0.0       0.0
Z:  0.0
```
``iterNum = 1``
``````
while iterNum&lt;=10:
iterNum+=1
type_problem = 1
if type_problem == 1:
num = max(Cj-Zj)
index = np.where((Cj-Zj)==num)
index = index
v_enter = variables[index]
else:
num = min(Cj-Zj)
index = np.where((Cj-Zj)==num)
index = index
v_enter = variables[index]

b = A[:,index]
k = -1
d = 10000

for i in range(len(Q)):
if b[i]&gt;0:
div = Q[i]/b[i]
if d&gt;=div:
d = div
k = i
if k == -1:
print('Solution is infinty ')
break
else:
num2 = k

v_leave = struct2_var_base[num2]
struct2_var_base[num2] = v_enter
pivot = A[num2,index]
Ci[num2] = Cj[index]
A[num2,:] = A[num2,:]/pivot
Q[num2] = Q[num2]/pivot

#Row operations:

for i in range(num_consts):

if i!= num2:
Q[i] = Q[i] - A[i,index]*Q[num2]
A[i,:] = A[i,:] - A[i,index]*A[num2,:]
Z = sum(np.multiply(Ci,Q))
for i in  range(len(A[0,:])):
Zj[i] = sum(np.multiply(A[:,i],Ci))

vars_at_moment = []
for i in range(num_consts):
vars_at_moment.append(struct2_var_base[i])

print('=====Iteration',iterNum,'=======')
print('Enter: ',v_enter)
print('Leave: ',v_leave)
print('Pivot: ',round(pivot,3))

print('========')

print('=======================================================================================================')
print("Variables:                              ",get_row(np.arange(start=1,stop=len(A[0,:])+1,step = 1 )))
print("Cj:                                     ",get_row(Cj))
print("Basic        |Value       |RHS")
for i in range(num_consts):
print('|',"{0:&gt;10}".format(vars_at_moment[i]),'|',"{0:&gt;10}".format(Ci[i]),'|',"{0:&gt;10}".format(round(Q[i],3)),'|',get_row(A[i]),'|')

print('=======================================================================================================')
print('Zj:                                     ',get_row(Zj))
print('Cj-Zj:                                  ',get_row(Cj-Zj))
print('Z: ',round(Z,3))
if type_problem ==1:
temp = max(Cj-Zj)
if temp&lt;=0:
break
else:
temp = min(Cj-Zj)
if temp&gt;=0:
break
``````
```=====Iteration 2 =======
Enter:  x1
Leave:  x7
Pivot:  5.0
========
=======================================================================================================
Variables:                                        1         2         3         4         5         6         7
Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0
Basic        |Value       |RHS
|         x4 |        0.0 |       20.8 |        0.0       0.8       2.6       1.0       0.0       0.0      -0.6 |
|         x5 |        0.0 |        3.2 |        0.0       0.2      -0.6       0.0       1.0       0.0      -0.4 |
|         x6 |        0.0 |       18.6 |        0.0       0.6       2.2       0.0       0.0       1.0      -0.2 |
|         x1 |       20.0 |       11.4 |        1.0       0.4       0.8       0.0       0.0       0.0       0.2 |
=======================================================================================================
Zj:                                            20.0       8.0      16.0       0.0       0.0       0.0       4.0
Cj-Zj:                                          0.0       2.0      -1.0       0.0       0.0       0.0      -4.0
Z:  228.0
=====Iteration 3 =======
Enter:  x2
Leave:  x5
Pivot:  0.2
========
=======================================================================================================
Variables:                                        1         2         3         4         5         6         7
Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0
Basic        |Value       |RHS
|         x4 |        0.0 |        8.0 |        0.0       0.0       5.0       1.0      -4.0       0.0       1.0 |
|         x2 |       10.0 |       16.0 |        0.0       1.0      -3.0       0.0       5.0       0.0      -2.0 |
|         x6 |        0.0 |        9.0 |        0.0       0.0       4.0       0.0      -3.0       1.0       1.0 |
|         x1 |       20.0 |        5.0 |        1.0       0.0       2.0       0.0      -2.0       0.0       1.0 |
=======================================================================================================
Zj:                                            20.0      10.0      10.0       0.0      10.0       0.0       0.0
Cj-Zj:                                          0.0       0.0       5.0       0.0     -10.0       0.0       0.0
Z:  260.0
=====Iteration 4 =======
Enter:  x3
Leave:  x4
Pivot:  5.0
========
=======================================================================================================
Variables:                                        1         2         3         4         5         6         7
Cj:                                            20.0      10.0      15.0       0.0       0.0       0.0       0.0
Basic        |Value       |RHS
|         x3 |       15.0 |        1.6 |        0.0       0.0       1.0       0.2      -0.8       0.0       0.2 |
|         x2 |       10.0 |       20.8 |        0.0       1.0       0.0       0.6       2.6       0.0      -1.4 |
|         x6 |        0.0 |        2.6 |        0.0       0.0       0.0      -0.8       0.2       1.0       0.2 |
|         x1 |       20.0 |        1.8 |        1.0       0.0       0.0      -0.4      -0.4       0.0       0.6 |
=======================================================================================================
Zj:                                            20.0      10.0      15.0       1.0       6.0       0.0       1.0
Cj-Zj:                                          0.0       0.0       0.0      -1.0      -6.0       0.0      -1.0
Z:  268.0
```  