├── README.md
├── bashrc.sh
├── day1
    ├── Class 1 (10.1.17).pdf
    ├── gauss-seidel.c
    └── gauss-seidel.c.out
├── day2
    ├── Class 2 (17.1.17).pdf
    ├── bsf-optimal.pdf
    ├── bsf.c
    ├── bsf.c.out
    ├── bsf_optimal.c
    ├── bsf_optimal.c.out
    ├── day2.pdf
    ├── gauss-elimination.c
    └── gauss-elimination.c.out
├── day3
    ├── Assignment 3 Lab.pdf
    ├── simplex.c
    ├── simplex.c.out
    └── simplex.pdf
├── day4
    ├── Class 4 (31.1.17).pdf
    ├── big_m.c
    ├── big_m.c.out
    └── output.pdf
├── day5
    ├── Big_M_menu.pdf
    ├── Class 5 (07.02.17).pdf
    ├── big_m_menu.c
    └── big_m_menu.c.out
├── day6
    ├── Class 6 (28.02.17).pdf
    ├── dual_simplex.c
    ├── dual_simplex.c.out
    ├── revised_simplex.c
    └── revised_simplex.c.out
├── day7
    ├── 2phase_simplex.c
    ├── 2phase_simplex.c.out
    └── Lab on Two phase Simplex.pdf
├── day8
    ├── Class 8 (14.03.17).pdf
    ├── branch&bound.cpp
    ├── cutting_plane.cpp
    ├── cutting_plane.cpp.out
    └── day8.pdf
├── day9
    ├── question.pdf
    ├── transport.c
    ├── transport.c.out
    └── transport.pdf
├── index.pdf
└── or_lab.sh


/README.md:
--------------------------------------------------------------------------------
 1 | # OR Lab
 2 | 
 3 | This repository that contains the code I've submitted for the course MA39014 - Operations Research Lab, IIT Kharagpur.
 4 | 
 5 | ### Getting started
 6 | 
 7 | - Clone this repository
 8 | - Set this up in your shell configuration file (`~/.bashrc`, `~/.zshrc/` or `~/.fishrc`). This code snippet can also be found in [`bashrc.sh file`](https://github.com/athityakumar/or_lab/blob/master/bashrc.sh)
 9 | 
10 | ```
11 | export OR_LAB_REPO_PATH=/path/to/or_lab/
12 | source $OR_LAB_REPO_PATH/or_lab.sh
13 | ```
14 | - Restart your terminal, or just source your shell configuration file (say, `source ~/.bashrc`for bash shell)
15 | 
16 | ### Shell Commands
17 | 
18 | All tweaks required can be made, by incorporating the changes in the [`or_lab.sh`](https://github.com/athityakumar/or_lab/blob/master/or_lab.sh) file
19 | 
20 | - `or_c` : Single command to compile and execute the `*.c` file. For example, `or_c filename.c`
21 | - `or_cpp` : Single command to compile and execute the `*.cpp` file. For example, `or_cpp filename.cpp` 
22 | - `or_push` : Command to commit and push your changes to the remote git repository. You may have to set your git remote `origin` properly to point to a repository you have push access to. For example, `or_push "Makes these changes"`.
23 | - `or_pull` : Single command to commit and push your changes to the remote git repository. You may have to set your git remote `origin` properly to point to a repository you have push access to. For example, simply use `or_pull` from the root directory of the git repository.
24 | - `or_cd` : Command to directly change the directory to this path. Made for fellow developers, who might be lazy to type 6 extra characters. For example, `or_cd`.
25 | 
26 | ### License
27 | 
28 | Feel free to use any code present in this repository, without any restrictions.


--------------------------------------------------------------------------------
/bashrc.sh:
--------------------------------------------------------------------------------
1 | # Copy paste this code into ~/.bashrc file with proper repo path. This is just an example path.
2 | # IMPORTANT NOTE : Don't change the variable from "OR_LAB_REPO_PATH" to anything else.
3 | 
4 | export OR_LAB_REPO_PATH=~/or_lab
5 | source $OR_LAB_REPO_PATH/or_lab.sh


--------------------------------------------------------------------------------
/day1/Class 1 (10.1.17).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day1/Class 1 (10.1.17).pdf


--------------------------------------------------------------------------------
/day1/gauss-seidel.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | void main()
 4 | {
 5 | 
 6 | 	int n,i,j,key=1;
 7 | 	double er,val,x[100],x0[100],sum,a[100][100],b[100]; 
 8 | 	printf("\n\n Enter stopping criteria (er) : ");
 9 | 	scanf("%lf",&er);
10 | 	printf("\n Enter size of matrix (n) : ");
11 | 	scanf("%d",&n);
12 | 	for(i=0;i<n;i++)
13 | 	{
14 | 		for(j=0;j<n;j++)
15 | 		{
16 | 			printf("\n Input for marix A's row %d column %d : ",(i+1),(j+1));
17 | 			scanf("%lf",&a[i][j]);
18 | 		}
19 | 	}
20 | 	
21 | 	printf("\n");	
22 | 	for(i=0;i<n;i++)
23 | 	{
24 | 		printf("\n Input for matrix B's row %d column 1 : ",(i+1));
25 | 		scanf("%lf",&b[i]);
26 | 	}
27 | 
28 | 
29 | 
30 | 	for(i=0;i<n;i++)
31 | 	{
32 | 		x0[i] = 0.0;
33 | 	}
34 | 
35 | 	do
36 | 	{ 
37 | 		key = 0;
38 | 
39 | 		for(i=0;i<n;i++)
40 | 		{
41 | 			sum = b[i];
42 | 			for(j=0;j<n;j++)
43 | 			{
44 | 				if(j!=i)
45 | 				{
46 | 					sum -= (a[i][j]*x0[j]);
47 | 				}
48 | 			}
49 | 			x[i] = sum/a[i][i];
50 | 			val = (x[i] - x0[i]) / x[i];
51 | 			if(val < 0.0)
52 | 			{
53 | 				val*=(-1.0);
54 | 			}
55 | 			if(val>er)
56 | 			{
57 | 				key = 1;
58 | 				x0[i] = x[i];
59 | 			}
60 | 		}
61 | 
62 | 	}while(key==1);
63 | 
64 | 	printf("\n\n Printing solved matrix x.");
65 | 	for(i=0;i<n;i++)
66 | 	{
67 | 		printf("\n x[%d] = %lf",i,x[i]);
68 | 	}
69 | 	
70 | 	printf("\n\n");
71 | 
72 | }
73 | 


--------------------------------------------------------------------------------
/day1/gauss-seidel.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day1/gauss-seidel.c.out


--------------------------------------------------------------------------------
/day2/Class 2 (17.1.17).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day2/Class 2 (17.1.17).pdf


--------------------------------------------------------------------------------
/day2/bsf-optimal.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day2/bsf-optimal.pdf


--------------------------------------------------------------------------------
/day2/bsf.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | 
  3 | int gauss_elimination(double a[][100], int m,int n, int new2darr[], int option,int r)
  4 | {
  5 |     int i,j,k,key,flag,track=0;
  6 | 	double er=0.001,val,x[100],x0[100],sum,a_new[100][100],c;
  7 |     for(i=0;i<m;i++)
  8 |     {
  9 |         x[i] = 0.0;
 10 |     }
 11 |     for(j=0; j<m; j++)
 12 |     {
 13 |         for(i=0; i<m; i++)
 14 |         {
 15 |             if(i>j)
 16 |             {
 17 |                 c=a[i][j]/a[j][j];
 18 |                 for(k=0; k<m+1; k++)
 19 |                 {
 20 |                     a[i][k]=a[i][k]-c*a[j][k];
 21 |                 }
 22 |             }
 23 |         }
 24 |     }
 25 |     x[m-1]=a[m-1][m]/a[m-1][m-1];
 26 |     for(i=m-1; i>=0; i--)
 27 |     {
 28 |         sum=0;
 29 |         for(j=i+1; j<m; j++)
 30 |         {
 31 |             sum=sum+a[i][j]*x[j];
 32 |         }
 33 |         x[i]=(a[i][m]-sum)/a[i][i];
 34 |     }
 35 |     int check_infeasibility = 0,check_degeneracy = 0;
 36 |     for(i=0,j=0;i<n;i++)
 37 |     {
 38 |         flag = 0;
 39 |         for(k=0;k<(n-m);k++)
 40 |         {
 41 |             if(new2darr[k] == i)
 42 |                 {
 43 |                     flag = 1;
 44 |                 }
 45 |         }
 46 |         if (flag==0)
 47 |         {   
 48 |             if (x[j] < 0)
 49 |             {
 50 |                 check_infeasibility = 1;
 51 |             }
 52 |         }
 53 |     }
 54 |     for(i=0;i<(n-m);i++)
 55 |     {
 56 |         for(j=i+1;j<(n-m);j++)
 57 |         {
 58 |             if(x[i] == x[j] && x[i] > 0)
 59 |             {
 60 |                 check_degeneracy = 1;
 61 |             }
 62 |         }
 63 |     }
 64 |     if((check_infeasibility==1 && option==1)||(check_degeneracy==1 && option ==3)||(check_infeasibility==0 && check_degeneracy==0 && option==2))
 65 |     {
 66 |         for(j=0;j<r;j++)
 67 |         {
 68 |             printf(" x%d = 0.000000 ",new2darr[j]+1);
 69 |         }
 70 |         for(i=0,j=0;i<n;i++)
 71 |         {
 72 |             flag = 0;
 73 |             for(k=0;k<(n-m);k++)
 74 |             {
 75 |                 if(new2darr[k] == i)
 76 |                     {
 77 |                         flag = 1;
 78 |                     }
 79 |             }
 80 |             if (flag==0)
 81 |             {                        
 82 |                 printf(" x%d = %lf ",i+1,x[j++]);
 83 |             }
 84 |         }
 85 |         return 1;
 86 |     }
 87 |     else
 88 |     {
 89 |         return 0;
 90 |     }
 91 | }
 92 | 
 93 | 
 94 | int number_combine(int arr[], int data[], int start, int end,int index, int r, int s)
 95 | {
 96 |     int i;
 97 |     if (index == r)
 98 |     {
 99 |         return(s+1);
100 |     }
101 |  
102 |     for (i=start; i<=end && end-i+1 >= r-index; i++)
103 |     {
104 |         data[index] = arr[i];
105 |         s = number_combine(arr, data, i+1, end, index+1, r, s);    
106 |     }
107 |     return s;
108 | }
109 | 
110 | 
111 | int * combine(int arr[], int data[], int start, int end,int index, int r, int* newarr, int *l)
112 | {
113 | 	int j,i;
114 |     if (index == r)
115 |     {
116 |         for (j=0; j<r; j++)
117 | 		{
118 |         	*(newarr + *l) = data[j];
119 |             (*l)++;
120 |         }
121 |         return newarr;
122 |     }
123 |  
124 |     for (i=start; i<=end && end-i+1 >= r-index; i++)
125 |     {
126 |         data[index] = arr[i];
127 |         newarr = combine(arr, data, i+1, end, index+1, r, newarr, l);    
128 |     }
129 |     return newarr;
130 | }
131 | 
132 | 
133 | void main () {
134 | 
135 |     int i,j,m,n,option;
136 |     printf("\n Enter number of unknowns(n) : ");
137 |     scanf("%d",&n);
138 |     printf(" Enter number of equations (m) : ");
139 |     scanf("%d",&m);
140 |     double a[m][n],b[m];
141 |     printf("\n");
142 |     for(i=0;i<m;i++)
143 |     {
144 |         for(j=0;j<n;j++)
145 |         {
146 |             printf(" Input for marix a's row %d column %d : ",(i+1),(j+1));
147 |             scanf("%lf",&a[i][j]);
148 |         }
149 |     }
150 |     printf("\n");
151 |     for(i=0;i<m;i++)
152 |     {
153 |         printf(" Input for matrix B's row %d column 1 : ",(i+1));
154 |         scanf("%lf",&b[i]);
155 |     }
156 |     printf("\n");
157 |     printf(" \n\n 1 : Infeasible solution \n 2 : Feasible solution \n 3. Degenerate solution \n Enter option (1-3): ");
158 |     scanf("%d",&option);
159 | 
160 |     int arr[n],k;
161 |     for(i=0;i<n;i++)
162 |     {
163 |         arr[i] = i;
164 |     }
165 |     int r = n-m;
166 |     int data[r];
167 |     int nc = number_combine(arr, data, 0, n-1, 0, r,0);
168 |     int *getarr;
169 |     int newarr[nc*r+1];
170 |     int new2darr[nc+1][r+1];
171 |     getarr = newarr;
172 |     int l_start = 0;
173 |     int *l = &l_start;
174 |     getarr = combine(arr, data, 0, n-1, 0, r, getarr, l);
175 |     for (i=0;i<nc;i++)
176 |     {
177 |         for(j=0;j<r;j++)
178 |         {
179 |             new2darr[i][j] = newarr[i*r+j];
180 |         }
181 |     }
182 | 
183 |     double a_new[100][100];
184 |     int flag, track, h,result=0;
185 | 
186 |     for(i=0;i<nc;i++)
187 |     {
188 |         printf("\n");
189 |         // for(j=0;j<r;j++)
190 |         // {
191 |         //     printf(" x%d = 0 ",new2darr[i][j]+1);
192 |         // }
193 |         track = 0;
194 |         for(j=0;j<n;j++)
195 |         {
196 |             flag = 0;
197 |             for(k=0;k<(n-m);k++)
198 |             {
199 |                 if(new2darr[i][k] == j)
200 |                     {
201 |                         flag = 1;
202 |                     }
203 |             }
204 |             if (flag==0)
205 |             {
206 |                 for(h=0;h<m;h++)
207 |                 {
208 |                     a_new[h][j-track] = a[h][j];                
209 |                 }
210 |             }
211 |             else
212 |             {
213 |                 track = track+1;
214 |             }
215 |         }
216 |         for(h=0;h<m;h++)
217 |         {
218 |             a_new[h][m] = b[h];
219 |         }
220 |         result += gauss_elimination(a_new,m,n,new2darr[i],option,r);
221 |     }
222 |     if(result==0)
223 |     {
224 |         printf("No such solution found.");
225 |     }
226 | 
227 |     printf("\n\n");
228 | }


--------------------------------------------------------------------------------
/day2/bsf.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day2/bsf.c.out


--------------------------------------------------------------------------------
/day2/bsf_optimal.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | 
  3 | double gauss_elimination(double a[][100], int m,int n, int new2darr[], double objective[])
  4 | {
  5 |     int i,j,k,key,flag,track=0;
  6 |     double er=0.001,val,x[100],x0[100],sum,a_new[100][100],c;
  7 |     for(i=0;i<m;i++)
  8 |     {
  9 |         x[i] = 0.0;
 10 |     }
 11 |     for(j=0; j<m; j++)
 12 |     {
 13 |         for(i=0; i<m; i++)
 14 |         {
 15 |             if(i>j)
 16 |             {
 17 |                 c=a[i][j]/a[j][j];
 18 |                 for(k=0; k<m+1; k++)
 19 |                 {
 20 |                     a[i][k]=a[i][k]-c*a[j][k];
 21 |                 }
 22 |             }
 23 |         }
 24 |     }
 25 |     x[m-1]=a[m-1][m]/a[m-1][m-1];
 26 |     for(i=m-1; i>=0; i--)
 27 |     {
 28 |         sum=0;
 29 |         for(j=i+1; j<m; j++)
 30 |         {
 31 |             sum=sum+a[i][j]*x[j];
 32 |         }
 33 |         x[i]=(a[i][m]-sum)/a[i][i];
 34 |     }
 35 |     int check_infeasibility = 0,check_degeneracy = 0;
 36 |     double obj_val=0.0;
 37 |     for(i=0,j=0;i<n;i++)
 38 |     {
 39 |         flag = 0;
 40 |         for(k=0;k<(n-m);k++)
 41 |         {
 42 |             if(new2darr[k] == i)
 43 |                 {
 44 |                     flag = 1;
 45 |                 }
 46 |         }
 47 |         if (flag==0)
 48 |         {   
 49 |             if (x[j] < 0)
 50 |             {
 51 |                 check_infeasibility = 1;
 52 |             }
 53 |             else
 54 |             {
 55 |                 obj_val += (objective[i]*x[j]);
 56 |             }
 57 |             printf(" x%d = %lf ",i+1,x[j++]);
 58 |         }
 59 |     }
 60 |     for(i=0;i<(n-m);i++)
 61 |     {
 62 | 
 63 |         for(j=i+1;j<(n-m);j++)
 64 |         {
 65 |             if(x[i] == x[j] && x[i] > 0)
 66 |             {
 67 |                 check_degeneracy = 1;
 68 |             }
 69 |         }
 70 |     }
 71 |     if(check_degeneracy==1)
 72 |     {
 73 |         printf(" - Degenerate solution");
 74 |     }
 75 |     if(check_infeasibility==0 && check_degeneracy==0)
 76 |     {
 77 |         printf(" - Basic feasible solution");
 78 |     }
 79 |     if(check_infeasibility==1)
 80 |     {
 81 |         obj_val = 0.0;
 82 |         printf(" - Infeasible solution");
 83 |     }
 84 |     else
 85 |     {
 86 |         printf(" - Objective function value = %lf",obj_val);
 87 |     }
 88 |     return obj_val;
 89 | }
 90 | 
 91 | 
 92 | int number_combine(int arr[], int data[], int start, int end,int index, int r, int s)
 93 | {
 94 |     int i;
 95 |     if (index == r)
 96 |     {
 97 |         return(s+1);
 98 |     }
 99 |  
100 |     for (i=start; i<=end && end-i+1 >= r-index; i++)
101 |     {
102 |         data[index] = arr[i];
103 |         s = number_combine(arr, data, i+1, end, index+1, r, s);    
104 |     }
105 |     return s;
106 | }
107 | 
108 | 
109 | int * combine(int arr[], int data[], int start, int end,int index, int r, int* newarr, int *l)
110 | {
111 |     int j,i;
112 |     if (index == r)
113 |     {
114 |         for (j=0; j<r; j++)
115 |         {
116 |             *(newarr + *l) = data[j];
117 |             (*l)++;
118 |         }
119 |         return newarr;
120 |     }
121 |  
122 |     for (i=start; i<=end && end-i+1 >= r-index; i++)
123 |     {
124 |         data[index] = arr[i];
125 |         newarr = combine(arr, data, i+1, end, index+1, r, newarr, l);    
126 |     }
127 |     return newarr;
128 | }
129 | 
130 | 
131 | void main () {
132 |     int i,j,m,n,optimal;
133 |     printf("\n Enter number of unknowns (n) : ");
134 |     scanf("%d",&n);
135 |     printf(" Enter number of equations (m) : ");
136 |     scanf("%d",&m);
137 |     double a[m][n],b[m],objective_function[n];
138 |     printf("\n");
139 |     for(i=0;i<m;i++)
140 |     {
141 |         for(j=0;j<n;j++)
142 |         {
143 |             printf(" Input for marix A's row %d column %d : ",(i+1),(j+1));
144 |             scanf("%lf",&a[i][j]);
145 |         }
146 |     }
147 |     printf("\n");
148 |     for(i=0;i<m;i++)
149 |     {
150 |         printf(" Input for matrix B's row %d column 1 : ",(i+1));
151 |         scanf("%lf",&b[i]);
152 |     }
153 |     printf("\n");
154 |     for(i=0;i<n;i++)
155 |     {
156 |         printf(" Input for objective function's coefficient of x%d : ",(i+1));
157 |         scanf("%lf",&objective_function[i]);
158 |     }
159 |     printf(" \n\n 1 : Maximize \n 2 : Minimize \n Enter optimization technique for objective function (1 or 2) : ");
160 |     scanf("%d",&optimal);
161 |     int arr[n],k;
162 |     for(i=0;i<n;i++)
163 |     {
164 |         arr[i] = i;
165 |     }
166 |     int r = n-m;
167 |     int data[r];
168 |     int nc = number_combine(arr, data, 0, n-1, 0, r,0);
169 |     int *getarr;
170 |     int newarr[nc*r+1];
171 |     int new2darr[nc+1][r+1];
172 |     getarr = newarr;
173 |     int l_start = 0;
174 |     int *l = &l_start;
175 |     getarr = combine(arr, data, 0, n-1, 0, r, getarr, l);
176 |     for (i=0;i<nc;i++)
177 |     {
178 |         for(j=0;j<r;j++)
179 |         {
180 |             new2darr[i][j] = newarr[i*r+j];
181 |         }
182 |     }
183 | 
184 |     double a_new[100][100],sum[nc],replace;
185 |     int flag, track, h;
186 | 
187 |     for(i=0;i<nc;i++)
188 |     {
189 |         printf("\n");
190 |         for(j=0;j<r;j++)
191 |         {
192 |             printf(" x%d = 0.000000 ",new2darr[i][j]+1);
193 |         }
194 |         track = 0;
195 |         for(j=0;j<n;j++)
196 |         {
197 |             flag = 0;
198 |             for(k=0;k<(n-m);k++)
199 |             {
200 |                 if(new2darr[i][k] == j)
201 |                     {
202 |                         flag = 1;
203 |                     }
204 |             }
205 |             if (flag==0)
206 |             {
207 |                 for(h=0;h<m;h++)
208 |                 {
209 |                     a_new[h][j-track] = a[h][j];                
210 |                 }
211 |             }
212 |             else
213 |             {
214 |                 track = track+1;
215 |             }
216 |         }
217 |         for(h=0;h<m;h++)
218 |         {
219 |             a_new[h][m] = b[h];
220 |         }
221 |         sum[i] = gauss_elimination(a_new,m,n,new2darr[i],objective_function);
222 |     }
223 | 
224 |     if(optimal==1)
225 |     {
226 |         for (i = 0; i < nc; ++i)
227 |         {
228 |             for (j = i + 1; j < nc; ++j)
229 |             {
230 |                 if (sum[i] < sum[j])
231 |                 {
232 |                     replace =  sum[i];
233 |                     sum[i] = sum[j];
234 |                     sum[j] = replace;
235 |                 }
236 |             }
237 |         }
238 |     }
239 |     else
240 |     {
241 |         for (i = 0; i < nc; ++i)
242 |         {
243 |             for (j = i + 1; j < nc; ++j)
244 |             {
245 |                 if (sum[i] > sum[j])
246 |                 {
247 |                     replace =  sum[i];
248 |                     sum[i] = sum[j];
249 |                     sum[j] = replace;
250 |                 }
251 |             }
252 |         }               
253 |     }
254 | 
255 |     if(sum[0]==sum[1])
256 |     {
257 |         if(sum[0] == 0)
258 |         {
259 |             printf("\n\n No optimal solution.");
260 |         }
261 |         else
262 |         {
263 |             printf("\n\n Infinitely many optimal solutions, with optimal objective function value = %lf",sum[0]);
264 |         }
265 |     }
266 |     else
267 |     {
268 |         printf("\n\n Exactly one optimal solution, with optimal objective function value = %lf",sum[0]);        
269 |     }
270 |     printf("\n");
271 | }
272 | 


--------------------------------------------------------------------------------
/day2/bsf_optimal.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day2/bsf_optimal.c.out


--------------------------------------------------------------------------------
/day2/day2.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day2/day2.pdf


--------------------------------------------------------------------------------
/day2/gauss-elimination.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | 
  3 | void gauss_elimination(double a[][100], int m,int n, int new2darr[])
  4 | {
  5 |     int i,j,k,key,flag,track=0;
  6 |     double er=0.001,val,x[100],x0[100],sum,a_new[100][100],c;
  7 |     for(i=0;i<m;i++)
  8 |     {
  9 |         x[i] = 0.0;
 10 |     }
 11 |     for(j=0; j<m; j++)
 12 |     {
 13 |         for(i=0; i<m; i++)
 14 |         {
 15 |             if(i>j)
 16 |             {
 17 |                 c=a[i][j]/a[j][j];
 18 |                 for(k=0; k<m+1; k++)
 19 |                 {
 20 |                     a[i][k]=a[i][k]-c*a[j][k];
 21 |                 }
 22 |             }
 23 |         }
 24 |     }
 25 |     x[m-1]=a[m-1][m]/a[m-1][m-1];
 26 |     for(i=m-1; i>=0; i--)
 27 |     {
 28 |         sum=0;
 29 |         for(j=i+1; j<m; j++)
 30 |         {
 31 |             sum=sum+a[i][j]*x[j];
 32 |         }
 33 |         x[i]=(a[i][m]-sum)/a[i][i];
 34 |     }
 35 |     for(i=0,j=0;i<n;i++)
 36 |     {
 37 |         flag = 0;
 38 |         for(k=0;k<(n-m);k++)
 39 |         {
 40 |             if(new2darr[k] == i)
 41 |                 {
 42 |                     flag = 1;
 43 |                 }
 44 |         }
 45 |         if (flag==0)
 46 |         {   
 47 |             printf(" x%d = %lf ",i+1,x[j++]);
 48 |         }
 49 |     }
 50 | }
 51 | 
 52 | 
 53 | int number_combine(int arr[], int data[], int start, int end,int index, int r, int s)
 54 | {
 55 |     int i;
 56 |     if (index == r)
 57 |     {
 58 |         return(s+1);
 59 |     }
 60 |  
 61 |     for (i=start; i<=end && end-i+1 >= r-index; i++)
 62 |     {
 63 |         data[index] = arr[i];
 64 |         s = number_combine(arr, data, i+1, end, index+1, r, s);    
 65 |     }
 66 |     return s;
 67 | }
 68 | 
 69 | 
 70 | int * combine(int arr[], int data[], int start, int end,int index, int r, int* newarr, int *l)
 71 | {
 72 |     int j,i;
 73 |     if (index == r)
 74 |     {
 75 |         for (j=0; j<r; j++)
 76 |         {
 77 |             *(newarr + *l) = data[j];
 78 |             (*l)++;
 79 |         }
 80 |         return newarr;
 81 |     }
 82 |  
 83 |     for (i=start; i<=end && end-i+1 >= r-index; i++)
 84 |     {
 85 |         data[index] = arr[i];
 86 |         newarr = combine(arr, data, i+1, end, index+1, r, newarr, l);    
 87 |     }
 88 |     return newarr;
 89 | }
 90 | 
 91 | 
 92 | void main () {
 93 | 
 94 |     int i,j,m,n;
 95 |     printf("\n Enter number of unknowns(n) : ");
 96 |     scanf("%d",&n);
 97 |     printf(" Enter number of equations (m) : ");
 98 |     scanf("%d",&m);
 99 |     double a[m][n],b[m];
100 |     printf("\n");
101 |     for(i=0;i<m;i++)
102 |     {
103 |         for(j=0;j<n;j++)
104 |         {
105 |             printf(" Input for marix a's row %d column %d : ",(i+1),(j+1));
106 |             scanf("%lf",&a[i][j]);
107 |         }
108 |     }
109 |     printf("\n");
110 |     for(i=0;i<m;i++)
111 |     {
112 |         printf(" Input for matrix B's row %d column 1 : ",(i+1));
113 |         scanf("%lf",&b[i]);
114 |     }
115 | 
116 | 
117 |     int arr[n],k;
118 |     for(i=0;i<n;i++)
119 |     {
120 |         arr[i] = i;
121 |     }
122 |     int r = n-m;
123 |     int data[r];
124 |     int nc = number_combine(arr, data, 0, n-1, 0, r,0);
125 |     int *getarr;
126 |     int newarr[nc*r+1];
127 |     int new2darr[nc+1][r+1];
128 |     getarr = newarr;
129 |     int l_start = 0;
130 |     int *l = &l_start;
131 |     getarr = combine(arr, data, 0, n-1, 0, r, getarr, l);
132 |     for (i=0;i<nc;i++)
133 |     {
134 |         for(j=0;j<r;j++)
135 |         {
136 |             new2darr[i][j] = newarr[i*r+j];
137 |         }
138 |     }
139 | 
140 |     double a_new[100][100];
141 |     int flag, track, h;
142 | 
143 |     for(i=0;i<nc;i++)
144 |     {
145 |         printf("\n");
146 |         for(j=0;j<r;j++)
147 |         {
148 |             printf(" x%d = 0 ",new2darr[i][j]+1);
149 |         }
150 |         track = 0;
151 |         for(j=0;j<n;j++)
152 |         {
153 |             flag = 0;
154 |             for(k=0;k<(n-m);k++)
155 |             {
156 |                 if(new2darr[i][k] == j)
157 |                     {
158 |                         flag = 1;
159 |                     }
160 |             }
161 |             if (flag==0)
162 |             {
163 |                 for(h=0;h<m;h++)
164 |                 {
165 |                     a_new[h][j-track] = a[h][j];                
166 |                 }
167 |             }
168 |             else
169 |             {
170 |                 track = track+1;
171 |             }
172 |         }
173 |         for(h=0;h<m;h++)
174 |         {
175 |             a_new[h][m] = b[h];
176 |         }
177 |         gauss_elimination(a_new,m,n,new2darr[i]);
178 | 
179 |     }
180 | }


--------------------------------------------------------------------------------
/day2/gauss-elimination.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day2/gauss-elimination.c.out


--------------------------------------------------------------------------------
/day3/Assignment 3 Lab.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day3/Assignment 3 Lab.pdf


--------------------------------------------------------------------------------
/day3/simplex.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <math.h>
  3 | 
  4 | int next_iteration_index(double *ptr, int m, int n)
  5 | {
  6 |     int i,index=0;
  7 |     for(i=1;i<n-1;i++)
  8 |     {   
  9 |         if(*(ptr+(m-1)*n+i) < *(ptr+(m-1)*n+index))
 10 |         {
 11 |             index = i;
 12 |         }
 13 |     }
 14 |     if(*(ptr+(m-1)*n+index) > 0)
 15 |     {
 16 |         return -1;
 17 |     }
 18 |     else
 19 |     {
 20 |         if(*(ptr+(m-1)*n+index) == 0)
 21 |         {
 22 |             return -2;
 23 |         }
 24 |     }
 25 |     return index;
 26 | }
 27 | 
 28 | int pivot_index(double *ptr, int m, int n)
 29 | {
 30 |     int i,j=next_iteration_index(ptr,m,n),index=j;
 31 |     double vi = *(ptr+j),vn = *(ptr+n-1),min = vn/vi;
 32 |     for(i=1;i<m-1;i++)
 33 |     {
 34 |         vi = *(ptr+i*n+j);
 35 |         vn = *(ptr+i*n+n-1);
 36 |         if(vi>0 && (vn/vi)<min)
 37 |         {
 38 |             min = vn/vi;
 39 |             index = i*n+j;
 40 |         }
 41 |     }
 42 |     return index;
 43 | }
 44 | 
 45 | double * convert_pivot(double *ptr, int m, int n, int p_index)
 46 | {
 47 |     double p = *(ptr+p_index);
 48 |     p = 1/p;
 49 |     *(ptr+p_index) = p;
 50 |     return ptr;
 51 | }
 52 | 
 53 | double * convert_row(double *ptr, int m, int n, int p_index)
 54 | {
 55 |     double p = *(ptr+p_index),r;
 56 |     int p_row = p_index/n,p_col=p_index%n,i;
 57 |     for(i=0;i<n;i++)
 58 |     {
 59 |         if(i!=p_col)
 60 |         {
 61 |             r = *(ptr+p_row*n+i);
 62 |             r = r*p; 
 63 |             *(ptr+p_row*n+i) = r;       
 64 |         }
 65 |     }
 66 |     return ptr;
 67 | }
 68 | 
 69 | double * convert_column(double *ptr, int m, int n, int p_index)
 70 | {
 71 |     double p = *(ptr+p_index),c;
 72 |     int p_row = p_index/n,p_col = p_index%n,i;   
 73 |     for(i=0;i<m;i++)
 74 |     {
 75 |         if(i!=p_row)
 76 |         {
 77 |             c = *(ptr+i*n+p_col);
 78 |             c = (-1)*c*p;
 79 |             *(ptr+i*n+p_col) = c;                  
 80 |         }
 81 |     }
 82 |     return ptr;
 83 | }
 84 | 
 85 | double * convert_others(double *ptr, int m, int n, int p_index)
 86 | {
 87 |     double p = *(ptr+p_index),c,r,s;
 88 |     int p_row = p_index/n,p_col = p_index%n,i,j;   
 89 |     for(i=0;i<m;i++)
 90 |     {
 91 |         for(j=0;j<n;j++)
 92 |         {
 93 |             if(i!=p_row && j!=p_col)
 94 |             {
 95 |                 r = *(ptr+p_row*n+j);
 96 |                 c = *(ptr+i*n+p_col);
 97 |                 s = *(ptr+i*n+j);
 98 |                 s += (c*r/p); 
 99 |                 *(ptr+i*n+j) = s;                                  
100 |             }
101 |         }
102 |     }
103 |     return ptr;
104 | }
105 | 
106 | void print_array(double *ptr, int m, int n)
107 | {
108 |     int i,j;
109 |     for(i=0;i<m;i++)
110 |     {
111 |         printf("\n");
112 |         for(j=0;j<n;j++)
113 |         {
114 |             printf(" %lf ",*(ptr+i*n+j));       
115 |         }
116 |     }   
117 | }
118 | 
119 | void print_solution(double *ptr, int *ptr2, int m, int n)
120 | {
121 |     int i;
122 |     for(i=0;i<n;i++)
123 |     {
124 |         if(*(ptr2+i) != -1)
125 |         {
126 |             printf(" x%d = %lf ",*(ptr2+i)+1,*(ptr+i*n+n-1));       
127 |         }
128 |     }    
129 |     printf("\n Other variables are non-basic, i.e, 0.");
130 |     printf("\n Optimal solution z = %lf ",*(ptr+m*n-1));
131 |     if (next_iteration_index(ptr,m,n)==-2)
132 |     {
133 |         printf("\n Alternate solution exists.");
134 |     }
135 |     else
136 |     {
137 |         printf("\n Unique optimal solution - no alternate solution.");
138 |     }
139 | }
140 | 
141 | int * swap_variables(int *ptr2, int m, int n, int p)
142 | {
143 |     int p_row = p/n, p_col = p%n;
144 |     *(ptr2+p_col) = p_row;
145 |     return ptr2;
146 | }
147 | 
148 | double * simplex_solve(double *ptr, int *ptr2, int m, int n)
149 | {   
150 |     int p,i=0;
151 |     printf("\n\n Tableu from iteration  %d \n",i++);
152 |     print_array(ptr,m,n);    
153 |     printf("\n\n");   
154 |     while(next_iteration_index(ptr,m,n)!=-1)
155 |     {
156 |         printf(" Tableu from iteration  %d \n",i++);
157 |         p = pivot_index(ptr,m,n);
158 |         ptr2 = swap_variables(ptr2,m,n,p);
159 |         ptr = convert_pivot(ptr,m,n,p);
160 |         ptr = convert_row(ptr,m,n,p);
161 |         ptr = convert_column(ptr,m,n,p);
162 |         ptr = convert_others(ptr,m,n,p);
163 |         print_array(ptr,m,n);    
164 |         printf("\n\n");
165 |     }
166 |     print_solution(ptr,ptr2,m,n);
167 |     return ptr;
168 | }
169 | 
170 | void main()
171 | {
172 |     int m,n,i,j;
173 |     printf("\n Enter number of unknowns (n) : ");
174 |     scanf("%d",&n);
175 |     printf(" Enter number of equations (m) : ");
176 |     scanf("%d",&m);
177 |     m++;
178 |     n++;
179 |     double arr[m*n];
180 |     printf("\n");
181 |     for(i=0;i<m-1;i++)
182 |     {
183 |         for(j=0;j<n-1;j++)
184 |         {
185 |             printf(" Input for marix A's equation %d coeffiecient of x%d : ",(i+1),(j+1));
186 |             scanf("%lf",&arr[n*i+j]);
187 |         }
188 |     }
189 |     printf("\n");
190 |     for(i=0;i<m-1;i++)
191 |     {
192 |         printf(" Input for matrix B's - constant for equation %d : ",(i+1));
193 |         scanf("%lf",&arr[n*(i+1)-1]);
194 |     }
195 |     printf("\n");
196 |     for(i=0;i<n-1;i++)
197 |     {
198 |         printf(" Input for objective function's coefficient of x%d : ",(i+1));
199 |         scanf("%lf",&arr[(m-1)*n+i]);
200 |     }
201 | 
202 |     for(i=0;i<n-1;i++)
203 |     {
204 |         arr[(m-1)*n+i] *= (-1);
205 |     }
206 |     arr[m*n-1] = 0.0;
207 |     double *ptr;
208 |     int arr2[100], *ptr2;
209 |     for(i=0;i<n;i++)
210 |     {
211 |         arr2[i] = -1;
212 |     }
213 |     ptr = arr;
214 |     ptr2 = arr2;
215 |     ptr = simplex_solve(ptr,ptr2,m,n);
216 | }


--------------------------------------------------------------------------------
/day3/simplex.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day3/simplex.c.out


--------------------------------------------------------------------------------
/day3/simplex.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day3/simplex.pdf


--------------------------------------------------------------------------------
/day4/Class 4 (31.1.17).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day4/Class 4 (31.1.17).pdf


--------------------------------------------------------------------------------
/day4/big_m.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <math.h>
  3 | 
  4 | int next_iteration_index(double *ptr, int m, int n)
  5 | {
  6 |     int i,index=0;
  7 |     for(i=1;i<n-1;i++)
  8 |     {   
  9 |         if(*(ptr+(m-1)*n+i) < *(ptr+(m-1)*n+index))
 10 |         {
 11 |             index = i;
 12 |         }
 13 |     }
 14 |     if(*(ptr+(m-1)*n+index) > 0)
 15 |     {
 16 |         return -1;
 17 |     }
 18 |     else
 19 |     {
 20 |         if(*(ptr+(m-1)*n+index) == 0)
 21 |         {
 22 |             return -2;
 23 |         }
 24 |     }
 25 |     return index;
 26 | }
 27 | 
 28 | int pivot_index(double *ptr, int m, int n)
 29 | {
 30 |     int i,j=next_iteration_index(ptr,m,n),index=j;
 31 |     double vi = -1.0,vn = -1.0,min = 10000.0;
 32 |     for(i=0;i<m-1;i++)
 33 |     {
 34 |         vi = *(ptr+i*n+j);
 35 |         vn = *(ptr+i*n+n-1);
 36 |         if(vi>0 && (vn/vi)<min)
 37 |         {
 38 |             min = vn/vi;
 39 |             index = i*n+j;
 40 |         }
 41 |     }
 42 |     return index;
 43 | }
 44 | 
 45 | double * convert_pivot(double *ptr, int m, int n, int p_index)
 46 | {
 47 |     double p = *(ptr+p_index);
 48 |     p = 1/p;
 49 |     *(ptr+p_index) = p;
 50 |     return ptr;
 51 | }
 52 | 
 53 | double * convert_row(double *ptr, int m, int n, int p_index)
 54 | {
 55 |     double p = *(ptr+p_index),r;
 56 |     int p_row = p_index/n,p_col=p_index%n,i;
 57 |     for(i=0;i<n;i++)
 58 |     {
 59 |         if(i!=p_col)
 60 |         {
 61 |             r = *(ptr+p_row*n+i);
 62 |             r = r*p; 
 63 |             *(ptr+p_row*n+i) = r;       
 64 |         }
 65 |     }
 66 |     return ptr;
 67 | }
 68 | 
 69 | double * convert_column(double *ptr, int m, int n, int p_index)
 70 | {
 71 |     double p = *(ptr+p_index),c;
 72 |     int p_row = p_index/n,p_col = p_index%n,i;   
 73 |     for(i=0;i<m;i++)
 74 |     {
 75 |         if(i!=p_row)
 76 |         {
 77 |             c = *(ptr+i*n+p_col);
 78 |             c = (-1)*c*p;
 79 |             *(ptr+i*n+p_col) = c;                  
 80 |         }
 81 |     }
 82 |     return ptr;
 83 | }
 84 | 
 85 | double * convert_others(double *ptr, int m, int n, int p_index)
 86 | {
 87 |     double p = *(ptr+p_index),c,r,s;
 88 |     int p_row = p_index/n,p_col = p_index%n,i,j;   
 89 |     for(i=0;i<m;i++)
 90 |     {
 91 |         for(j=0;j<n;j++)
 92 |         {
 93 |             if(i!=p_row && j!=p_col)
 94 |             {
 95 |                 r = *(ptr+p_row*n+j);
 96 |                 c = *(ptr+i*n+p_col);
 97 |                 s = *(ptr+i*n+j);
 98 |                 s += (c*r/p); 
 99 |                 *(ptr+i*n+j) = s;                                  
100 |             }
101 |         }
102 |     }
103 |     return ptr;
104 | }
105 | 
106 | void print_array(double *ptr, int m, int n)
107 | {
108 |     int i,j;
109 |     for(i=0;i<m;i++)
110 |     {
111 |         printf("\n");
112 |         for(j=0;j<n;j++)
113 |         {
114 |             printf(" %lf ",*(ptr+i*n+j));       
115 |         }
116 |     }   
117 | }
118 | 
119 | void print_solution(double *ptr, int *ptr2, int m, int n)
120 | {
121 |     int i;
122 |     for(i=0;i<m-1;i++)
123 |     {
124 |         if(*(ptr2+i) != -1)
125 |         {
126 |             printf(" x%d = %lf ",*(ptr2+i)+1,*(ptr+i*n+n-1));       
127 |         }
128 |     }    
129 |     printf("\n Other variables are non-basic, i.e, 0.");
130 |     printf("\n Optimal solution z = %lf ",*(ptr+m*n-1));
131 |     if (next_iteration_index(ptr,m,n)==-2)
132 |     {
133 |         printf("\n Alternate solution exists.");
134 |     }
135 |     else
136 |     {
137 |         printf("\n Unique optimal solution - no alternate solution.");
138 |     }
139 | }
140 | 
141 | int * swap_variables(int *ptr2, int m, int n, int p)
142 | {
143 |     int p_row = p/n, p_col = p%n;
144 |     if(p_row==m-2)
145 |     {
146 |         *(ptr2+p_col) = 0;
147 |     }
148 |     else
149 |     {
150 |         *(ptr2+p_col) = p_row+1;
151 |     }
152 |     return ptr2;
153 | }
154 | 
155 | double * bigm_solve(double *ptr, int *ptr2, int m, int n, int obj_type)
156 | {   
157 |     int p,i=0;
158 |     printf("\n\n Tableu from iteration  %d \n",i++);
159 |     print_array(ptr,m,n);    
160 |     printf("\n\n");   
161 |     while(next_iteration_index(ptr,m,n)!=-1 && i<5)
162 |     {
163 |         printf(" Tableu from iteration  %d \n",i++);
164 |         p = pivot_index(ptr,m,n);
165 |         ptr2 = swap_variables(ptr2,m,n,p);
166 |         ptr = convert_pivot(ptr,m,n,p);
167 |         ptr = convert_row(ptr,m,n,p);
168 |         ptr = convert_column(ptr,m,n,p);
169 |         ptr = convert_others(ptr,m,n,p);
170 |         print_array(ptr,m,n);    
171 |         printf("\n\n");
172 |     }
173 |     if(obj_type == 1)
174 |     {
175 |         *(ptr + m*n -1) *= (-1);
176 |     }  
177 |     print_solution(ptr,ptr2,m,n);
178 |     return ptr;
179 | }
180 | 
181 | void main()
182 | {
183 |     int m,n,n_old,i,j,surplus=0,obj_type;
184 |     double M = 1000.0;
185 |     printf("\n Enter number of unknowns (n) : ");
186 |     scanf("%d",&n);
187 |     printf(" Enter number of equations (m) : ");
188 |     scanf("%d",&m);
189 |     m++;
190 |     n++;
191 |     n_old = n;
192 |     int option[m];
193 |     double arr[m*n];
194 |     printf("\n");
195 |     for(i=0;i<m-1;i++)
196 |     {
197 |         for(j=0;j<n-1;j++)
198 |         {
199 |             printf(" Input for marix A's equation %d coeffiecient of x%d : ",(i+1),(j+1));
200 |             scanf("%lf",&arr[n*i+j]);
201 |         }
202 |     }
203 |     printf("\n");
204 |     for(i=0;i<m-1;i++)
205 |     {
206 |         printf(" Input for matrix B's - constant for equation %d : ",(i+1));
207 |         scanf("%lf",&arr[n*(i+1)-1]);
208 |     }
209 |     printf("\n");
210 |     for(i=0;i<n-1;i++)
211 |     {
212 |         printf(" Input for objective function's coefficient of x%d : ",(i+1));
213 |         scanf("%lf",&arr[(m-1)*n+i]);
214 |     }
215 |     printf("\n");
216 |     for(i=0;i<m-1;i++)
217 |     {
218 |         printf(" Type of equation / inequation %d \n 1. Ax >= B \n 2. Ax = B \n 3. Ax <= B \n Enter your option : ",(i+1));
219 |         scanf("%d",&option[i]);
220 |         if(option[i]==1)
221 |         {
222 |             n++;
223 |         }
224 |     }
225 | 
226 |     printf("\n");
227 |     printf(" Type of optimization \n 1. Minimize \n 2. Maximize \n Enter your option : ");
228 |     scanf("%d",&obj_type);
229 | 
230 |     double bigm_arr[m*n];
231 |     for(i=0;i<m-1;i++)
232 |     {
233 |         for(j=0;j<n_old-1;j++)
234 |         {
235 |             bigm_arr[i*n+j] = arr[i*n_old+j];
236 |         }
237 |     }
238 |     for(i=0;i<m-1;i++)
239 |     {
240 |         if(option[i]==1)
241 |         {
242 |             for(j=n_old-1;j<n-1;j++)
243 |             {
244 |                 bigm_arr[i*n+j]= 0.0;
245 |             }
246 |             bigm_arr[i*n+n_old-1+surplus]= -1.0;
247 |             surplus++;
248 |         }
249 |     }    
250 |     for(i=0;i<m-1;i++)
251 |     {
252 |         bigm_arr[i*n+n-1] = arr[i*n_old+n_old-1]; 
253 |     }
254 |     for(j=0;j<n-1;j++)
255 |     {
256 |         bigm_arr[(m-1)*n+j] = arr[(m-1)*n_old+j];
257 |     }
258 |     double sum;
259 |     bigm_arr[m*n-1] = 0.0;
260 |     for(j=0;j<n;j++)
261 |     {
262 |         bigm_arr[(m-1)*n+j] *= -1;
263 |         sum = 0.0;
264 |         for(i=0;i<m-1;i++)
265 |         {
266 |             if(option[i]<3)
267 |             {
268 |                 sum += (bigm_arr[i*n+j]*M);                
269 |             }    
270 |         }      
271 |         bigm_arr[(m-1)*n+j] -= sum;
272 |     }
273 |     double *ptr;
274 |     int arr2[100], *ptr2;
275 |     ptr = bigm_arr;
276 |     ptr2 = arr2;
277 |     ptr = bigm_solve(ptr,ptr2,m,n,obj_type);
278 | }


--------------------------------------------------------------------------------
/day4/big_m.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day4/big_m.c.out


--------------------------------------------------------------------------------
/day4/output.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day4/output.pdf


--------------------------------------------------------------------------------
/day5/Big_M_menu.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day5/Big_M_menu.pdf


--------------------------------------------------------------------------------
/day5/Class 5 (07.02.17).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day5/Class 5 (07.02.17).pdf


--------------------------------------------------------------------------------
/day5/big_m_menu.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <math.h>
  4 | 
  5 | int get_slack(int ies[], int m)
  6 | {
  7 |     int slack = 0;
  8 |     for(int i=0; i<m; i++)
  9 |     {
 10 |         if(ies[i] == -1)
 11 |             slack++;
 12 |     }
 13 |     return slack;
 14 | }
 15 | 
 16 | int get_surplus(int ies[], int m)
 17 | {
 18 |     int surplus = 0;
 19 |     for(int i=0; i<m; i++)
 20 |     {
 21 |         if(ies[i] == 1)
 22 |             surplus++;
 23 |     }
 24 |     return surplus;
 25 | }
 26 | 
 27 | int get_artificial(int ies[], int m)
 28 | {
 29 |     int slack = get_slack(ies, m);
 30 |     return m - slack;
 31 | }
 32 | 
 33 | void initialize_table(float table[][100], float a[][100], float b[], float c[], int ies[], int m, int n)
 34 | {
 35 |     float cbv[100];
 36 |     for(int i=0; i<m; i++)
 37 |     {
 38 |         if(ies[i] >= 0)
 39 |             cbv[i] = -100000;
 40 |         else
 41 |             cbv[i] = 0;
 42 |     }
 43 |     int surplus = get_surplus(ies, m);
 44 |     for(int i=0; i<m; i++)
 45 |     {
 46 |         int curr_surplus = 0;
 47 |         for(int j=0; j<n; j++)
 48 |             table[i][j] = a[i][j];
 49 |         for(int j=n; j<n+surplus; j++)
 50 |             table[i][j] = 0;
 51 |         if(ies[i] == 1)
 52 |             table[i][n+curr_surplus++] = -1;
 53 |         table[i][n+surplus] = b[i];
 54 |     }
 55 |     for(int i=0; i<=n+surplus; i++)
 56 |     {
 57 |         float inner_product = 0;
 58 |         for(int j=0; j<m; j++)
 59 |             inner_product += table[j][i]*cbv[j];
 60 |         if(i>=n) table[m][i] = inner_product;
 61 |         else table[m][i] = inner_product - c[i];
 62 |     }
 63 | }
 64 | 
 65 | void copy_2d_array(float src[][100], float dest[][100], int m, int n)
 66 | {
 67 |     for(int i=0; i<m; i++)
 68 |     {
 69 |         for(int j=0; j<n; j++)
 70 |             dest[i][j] = src[i][j];
 71 |     }
 72 | }
 73 | 
 74 | void print_line(int len)
 75 | {
 76 |     for(int i=0; i<len; i++)
 77 |         printf("-");
 78 |     printf("\n");
 79 | }
 80 | 
 81 | void print_simplex_table(float arr[][100], int bv[], int nbv[], int m, int n)
 82 | {
 83 |     printf("\n");
 84 |     printf("         ");
 85 |     print_line(10*(n+1)+1);
 86 | 
 87 |     printf("         |");
 88 |     for(int i=0; i<n; i++)
 89 |     {
 90 |         printf("    X%d   |", nbv[i]+1);
 91 |     }
 92 |     printf("    Xb   |\n");
 93 | 
 94 |     print_line(10*(n+2));
 95 | 
 96 |     for(int i=0; i<=m; i++)
 97 |     {
 98 |         if(i!=m)
 99 |             printf("    X%d   |", bv[i]+1);
100 |         else 
101 |             printf("         |");
102 |         for(int j=0; j<=n; j++)
103 |             printf(" %+7.2f |", arr[i][j]);
104 |         printf("\n");
105 |         if(i!=m)
106 |             print_line(10*(n+2));
107 |         else 
108 |         {
109 |             printf("         ");
110 |             print_line(10*(n+1)+1);
111 |         }
112 |     }
113 |     printf("\n");
114 | }
115 | 
116 | void print_solution(float table[][100], int bv[], int nbv[], int m,
117 | int n, int surplus)
118 | {
119 |     float sol_array[100];
120 |     printf("\nThe solution is: \n");
121 |     for(int i=0; i<n+surplus; i++)
122 |     {
123 |         if(nbv[i] >= n) continue;
124 |         sol_array[nbv[i]] = 0;
125 |     }
126 |     for(int i=0; i<m; i++)
127 |     {
128 |         if(bv[i] >= n) continue;
129 |         sol_array[bv[i]] = table[i][n+surplus];
130 |     }
131 |     for(int i=0; i<n; i++)
132 |         printf("x%d = %f, ", i+1, sol_array[i]);
133 |     if (table[m][n+surplus]<0) 
134 |         printf("\nOptimal value is: %f\n\n", -1.0*table[m][n+surplus]);
135 |     else
136 |         printf("\nOptimal value is: %f\n\n", table[m][n+surplus]);
137 | }
138 | 
139 | int is_nearly_equal(float a, float b, float abs_err_th)
140 | {
141 |     int flag = 0;
142 |     float err = fabs(a-b);
143 |     if(err <= abs_err_th)
144 |         flag = 1;
145 |     return flag;
146 | }
147 | 
148 | int get_pivot_h(float table[][100], int m, int n)
149 | {
150 |     float min = 0;
151 |     int pivot_h = -1;
152 |     for(int i=0; i<n; i++)
153 |     {
154 |         float value = table[m][i];
155 |         if(value > 0 || is_nearly_equal(value, 0, pow(2, -6))) continue;
156 |         if(value < min || pivot_h == -1)
157 |         {
158 |             pivot_h = i;
159 |             min = table[m][i];
160 |         }
161 |     }
162 |     return pivot_h;
163 | }
164 | 
165 | int get_pivot_v(float table[][100], int pivot_h, int m, int n)
166 | {
167 |     float min = 0;
168 |     int pivot_v = -1;
169 |     for(int i=0; i<m; i++)
170 |     {
171 |         float ai = table[i][pivot_h];
172 |         float ratio = table[i][n]/ai;
173 |         if(ai < 0 || is_nearly_equal(ai, 0, pow(2, -6))) continue;
174 |         if(ratio < min || pivot_v == -1)
175 |         {
176 |             pivot_v = i;
177 |             min = ratio;
178 |         }
179 |     }
180 |     return pivot_v;
181 | }
182 | 
183 | void next_iteration(float table[][100], int bv[], int nbv[], int pivot_h, int pivot_v, int m, int n)
184 | {
185 |     float new_table[100][100];
186 |     float pivot = table[pivot_v][pivot_h];
187 | 
188 |     int temp = bv[pivot_v];
189 |     bv[pivot_v] = nbv[pivot_h];
190 |     nbv[pivot_h] = temp;
191 | 
192 |     new_table[pivot_v][pivot_h] = 1.0/pivot;
193 | 
194 |     for(int i=0; i<=n; i++)
195 |     {
196 |         if(i == pivot_h) continue;
197 |         new_table[pivot_v][i] = table[pivot_v][i]/pivot;
198 |     }
199 | 
200 |     for(int i=0; i<=m; i++)
201 |     {
202 |         if(i == pivot_v) continue;
203 |         new_table[i][pivot_h] = -table[i][pivot_h]/pivot;
204 |     }
205 | 
206 |     for(int i=0; i<=m; i++)
207 |     {
208 |         for(int j=0; j<=n; j++)
209 |         {
210 |             if(i == pivot_v || j == pivot_h) continue;
211 |             float p = pivot, s = table[i][j];
212 |             float q = table[i][pivot_h], r = table[pivot_v][j];
213 |             new_table[i][j] = (p*s - q*r)/p;
214 |         }
215 |     }
216 | 
217 |     copy_2d_array(new_table, table, m+1, n+1);
218 | }
219 | 
220 | void simplex(float a[][100], float b[], float c[], int ies[], int m, int n, int query_iteration, int choice)
221 | {
222 |     float table[100][100];
223 |     int bv[100], nbv[100];
224 | 
225 |     int iterations = 1, status = -1;
226 |     float ratio = 0;
227 | 
228 |     initialize_table(table, a, b, c, ies, m, n);
229 | 
230 |     int surplus = get_surplus(ies, m);
231 | 
232 |     for(int i=0; i<m; i++)
233 |         bv[i] = n+surplus+i;
234 |     for(int i=0; i<n + surplus; i++)
235 |         nbv[i] = i;
236 |     int flag=1;
237 |     while(flag)
238 |     {
239 |         int pos=0, neg=0, zero=0;
240 |         int pivot_h, pivot_v;
241 |         for(int i=0; i<n+surplus; i++)
242 |         {
243 |             if(is_nearly_equal(table[m][i], 0, pow(2, -6))) zero++;
244 |             else if(table[m][i] < 0) neg++;
245 |             else pos++;
246 |         }
247 |         if(neg == 0)
248 |         {
249 |             for(int j=0; j<m; j++)
250 |             {
251 |                 int index = bv[j] - n - surplus;
252 |                 if(index >= 0 && ies[index] != -1)
253 |                 {
254 |                     status = 3;
255 |                     flag = 0;
256 |                     break;
257 |                 }
258 |             }
259 |             if(flag != 0)
260 |             {
261 |                 if(zero > 0)
262 |                 {
263 |                     status = 1;
264 |                     flag = 0;
265 |                 }
266 |                 else
267 |                 {
268 |                     status = 0;
269 |                     flag = 0;
270 |                 }
271 |             }
272 |         }
273 |         else
274 |         {
275 |             pivot_h = get_pivot_h(table, m, n+surplus);
276 |             if(pivot_h < 0)
277 |             {
278 |                 printf("Error occurred!\n");
279 |                 exit(-1);
280 |             }
281 |             int pos_col=0, neg_col=0, zero_col=0;
282 |             for(int i=0; i<m; i++)
283 |             {
284 |                 if(is_nearly_equal(table[i][pivot_h], 0, pow(2, -6))) zero_col++;
285 |                 else if(table[i][pivot_h] < 0) neg_col++;
286 |                 else pos_col++;
287 |             }
288 |             if(pos_col == 0)
289 |             {
290 |                 status = 2;
291 |                 flag = 0;
292 |                 continue;
293 |             }
294 |             pivot_v = get_pivot_v(table, pivot_h, m, n+surplus);
295 |             if(pivot_v < 0)
296 |             {
297 |                 printf("Error occurred!\n");
298 |                 exit(-1);
299 |             }
300 |             if(query_iteration == 1)
301 |                 flag = 0;
302 |             else
303 |             {
304 |                 next_iteration(table, bv, nbv, pivot_h, pivot_v, m, n+surplus);
305 |                 iterations++;
306 |             }
307 |         }
308 |         if(query_iteration == iterations || flag == 0)
309 |         {
310 |             flag = 0;
311 |             if (choice==1)
312 |                 printf("Not yet supported\n");
313 |             else if (choice==2)
314 |                 printf("%d\n", iterations);
315 |             else if (choice==3)
316 |             {
317 |                 for(int i=0; i<n; i++)
318 |                     printf("X%d, ", nbv[i]+1);
319 |                 printf("\n%f\n", table[m][n+surplus]);
320 |             }
321 |             else if (choice==4)
322 |             {
323 |                 for(int i=0; i<m; i++)
324 |                     printf("X%d, ", bv[i]+1);
325 |                 float min_ratio = table[pivot_v][n+surplus] / table[pivot_v][pivot_h];
326 |                 printf("min_ratio = %f\n", min_ratio);
327 |             }
328 |             else if (choice==5)
329 |                 print_simplex_table(table, bv, nbv, m, n+surplus);
330 |             else if (choice==6)
331 |             {
332 |                 if(status == 0)
333 |                 {
334 |                     print_solution(table, bv, nbv, m, n, surplus);
335 |                     printf("Unique solution\n");
336 |                 }
337 |                 else if(status == 1)
338 |                 {
339 |                     print_solution(table, bv, nbv, m, n, surplus);
340 |                     printf("Alternate solution exists\n");
341 |                 }
342 |                 else if(status == 2)
343 |                 {
344 |                     printf("Unbounded Solution detected\n");
345 |                     printf("column %d has all elements 0 or negative\n", pivot_h+1);
346 |                 }
347 |                 else
348 |                     printf("Problem is Infeasible\n");
349 |             }
350 |         }
351 |     }
352 | }
353 | 
354 | 
355 | void main()
356 | {
357 |     int m,n;
358 |     float c[100], b[100], a[100][100];
359 |     int ies[100];
360 | 
361 |     printf("Enter number of equations (n) : ");
362 |     scanf("%d", &m);
363 |     printf("Enter number of variables (m) : ");
364 |     scanf("%d", &n);
365 |     printf("\nEnter the constraint equation:\n");
366 |     for(int i=0; i<m; i++)
367 |     {
368 |         printf("(Coefficients of constraint equation - %d)\n",i+1);
369 |         for(int j=0; j<n; j++)
370 |         {
371 |             printf("Input for matrix A's equation %d coefficient of x%d = ", i+1,j+1);
372 |             scanf("%f", &a[i][j]);
373 |         }
374 |         printf("\nType of equation \n -1 : Ax<=B \n 0 : Ax=B \n 1 : Ax>=B \n Enter your option : ");
375 |         scanf("%d", &ies[i]);
376 |         printf("Input for matrix B's constant for equation %d : ", i+1);
377 |         scanf("%f", &b[i]);
378 |         printf("\n");
379 |     }
380 | 
381 |     printf("\nEnter the coefficients of the maximizing equation (enter -ve coefficients for minimising function) :\n");
382 |     for(int i=0; i<n; i++)
383 |     {
384 |         printf("\nInput for objective function's coefficient of x%d : ",i+1);
385 |         scanf("%f", &c[i]);
386 |     }
387 | 
388 | 
389 |     int flag = 1;
390 |     int I;
391 |     while(flag)
392 |     {
393 |         printf("\n\n(1) List of all BFS\n(2) Number of Iterations to solve the problem\n(3) List of all Non-basic variables along with net evaluations in ith iteration\n(4) List of Basic variables along with min ratios in ith iteration\n(5) Simplex table of ith iteration\n(6) Optimal solution\n(7) Quit\n\nEnter your choice: ");
394 |         int ch;
395 |         scanf("%d", &ch);
396 |         if (ch==1)            
397 |             simplex(a, b, c, ies, m, n, -1, 1);
398 |         else if (ch==2)
399 |             simplex(a, b, c, ies, m, n, -1, 2);
400 |         else if (ch==3)
401 |         {
402 |             printf("Enter i: ");
403 |             scanf("%d", &I);
404 |             simplex(a, b, c, ies, m, n, I, 3);           
405 |         }
406 |         else if (ch==4)
407 |         {
408 |             printf("Enter i: ");
409 |             scanf("%d", &I);
410 |             simplex(a, b, c, ies, m, n, I, 4);                
411 |         }
412 |         else if (ch==5)
413 |         {
414 |             printf("Enter i: ");
415 |             scanf("%d", &I);
416 |             simplex(a, b, c, ies, m, n, I, 5);
417 |         }
418 |         else if (ch==6)
419 |             simplex(a, b, c, ies, m, n, -1, 6);
420 |         else if (ch==7)
421 |             flag = 0;
422 |         else
423 |         {
424 |             printf("Invalid choice\n");
425 |             flag = 0;
426 |         }      
427 |     }
428 | }
429 | 


--------------------------------------------------------------------------------
/day5/big_m_menu.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day5/big_m_menu.c.out


--------------------------------------------------------------------------------
/day6/Class 6 (28.02.17).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day6/Class 6 (28.02.17).pdf


--------------------------------------------------------------------------------
/day6/dual_simplex.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #define INFINITY -999
  3 | #define N 10
  4 | #define M 20
  5 | /***************************************************/
  6 | /***** Solves the LPP by "DUAL SIMPLEX" method *****/
  7 | /***************************************************/
  8 | void minimum(float *arr,int *arrminpos,int n);
  9 | /* Calculates the minimum valued position among the array arr having n elements. */
 10 | void maximum(float *arr,int *arrminpos,int n);
 11 | /* Calculates the minimum valued position among the array arr having n elements. */
 12 | void display (float c[],float b[],float a[][M],int basic[]);
 13 | /* Display the table */
 14 | void displayframe(float c[M]);
 15 | /* Displays the frame of the table */
 16 | void calctemp(float *,float [][M],float [],int []);
 17 | /* Calculates Zj-Cj */
 18 | 
 19 | int countmaxzterms;
 20 | int constraint;
 21 | 
 22 | void main()
 23 | {
 24 |   float c[M];
 25 |   /* Stores co-efficient of the objective function Max(z) */
 26 |   float a[N][M];    /* Stores the co-efficent of the constraints */
 27 |   float b[N];      /* Stores the values on RHS of constraints */
 28 |   float temp[M];    /* Stores the values of Zj-Cj*/
 29 |   int bminpos;     /* Stores the minimum valued position
 30 |             of {Zj-Cj} i.e. coming in variable */
 31 |   float maxratio[M];   /* Stores the value of the ratio Zj-Cj/a[i][j] */
 32 |   int maxratiomaxpos;  /* Stores the minimum valued position of
 33 |             b[i]/a[i][j] i.e. going out variable */
 34 |   float key;      /* Stores the key element */
 35 |   int gooutcol;     /* Stores the column number which goes out */
 36 |   int incomingcol;
 37 |   float z;       /* Stores the value of the objective function */
 38 |   float x[M];     /* Stores the value of the variables */
 39 |   int i,j;      /* Loop variables */
 40 |   int basic[N];     /* Stores the basic variable */
 41 |   int flag=0;    /* Terminating variable */
 42 |   int obj_type=0;
 43 |   /*** Initializing basic variables ***/
 44 | 
 45 |   for(i=0;i<M;i++)
 46 |     c[i]=x[i]=temp[i]=0;
 47 |   for(i=0;i<N;i++)
 48 |     for(j=0;j<M;j++)
 49 |       a[i][j]=0;
 50 | 
 51 |   /*** Inputing requisite amount of data ***/
 52 | 
 53 |   printf("\nEnter number of terms in objective function\n");
 54 |   scanf("%d",&countmaxzterms);
 55 |   printf("\nEnter the co-efficient\n");
 56 |   for(i=0;i<countmaxzterms;i++)
 57 |     scanf("%f",&c[i]);
 58 |   printf("\nEnter type of objective function (1: Minimize, else maximize) \n");
 59 |   scanf("%d",&obj_type);
 60 |   if(obj_type==1)
 61 |     for(i=0;i<countmaxzterms;i++)
 62 |       c[i] *= (-1.0);
 63 |   printf("\nYou have entered the function as follows:-\n");
 64 |   printf("\nMax z = ");
 65 |   for(i=0;i<countmaxzterms;i++)
 66 |   {
 67 |     if(i==0)
 68 |       printf("%g*x%d",c[i],i+1);
 69 |     else
 70 |       printf(" + %g*x%d",c[i],i+1);
 71 |   }
 72 |   printf("\nEnter number of constraint\n");
 73 |   scanf("%d",&constraint);
 74 |   int crit_type[constraint];
 75 |   printf("\nEnter the co-efficient of constraints\n");
 76 |   for(i=0;i<constraint;i++)
 77 |     for(j=0;j<countmaxzterms;j++)
 78 |       scanf("%f",&a[i][j]);
 79 |   for(i=0;i<constraint;i++)
 80 |     a[i][j++]=1;
 81 |   printf("\nEnter values of bi's\n");
 82 |   for(i=0;i<constraint;i++)
 83 |     scanf("%f",&b[i]);
 84 |   for(i=0;i<countmaxzterms+constraint;i++)
 85 |     basic[i]=(i+countmaxzterms);
 86 |   printf("\nYou have entered the function as follows:-\n");
 87 |   for(i=0;i<constraint;i++)
 88 |   {
 89 |     for(j=0;j<countmaxzterms;j++)
 90 |     {
 91 |       if(j==0)
 92 |         printf(" %g*x%d ",a[i][j],j+1);
 93 |       else
 94 |         printf(" + %g*x%d ",a[i][j],j+1);
 95 |     }
 96 |     printf(" <= %g\n",b[i]);
 97 |   }
 98 | 
 99 |   printf("\nEnter type of inequalities of above equations (1: >=, else <=) \n");
100 |   for(i=0;i<constraint;i++)
101 |     scanf("%d",&crit_type[i]);
102 |   for(i=0;i<constraint;i++)
103 |     if(crit_type[i]==1)
104 |       {
105 |         for(j=0;j<countmaxzterms;j++)
106 |           a[i][j] *= (-1.0);
107 |         b[i] *= (-1.0);        
108 |       }  
109 |   /*** Calculation for actual table ***/
110 | 
111 |   do
112 |   {
113 | 
114 |     /*** Terminating condition ***/
115 | 
116 |     for(i=0;i<constraint;i++)
117 |     {
118 |       flag=1;
119 |       if(b[i]<=0)
120 |       {
121 |         flag=0;
122 |         break;
123 |       }
124 |     }
125 | 
126 |     z=0;
127 |     calctemp(temp,a,c,basic);
128 |     printf("\n");
129 | 
130 |     display(c,b,a,basic);
131 |     printf("\n\tZj-Cj\t\t");
132 |     for(i=0;i<constraint+countmaxzterms;i++)
133 |       printf("%0.3g\t",temp[i]);
134 |     printf("\n\n");
135 | 
136 |     /*** Determining the outgoing column ***/
137 | 
138 |     minimum(b,&bminpos,constraint);
139 |     gooutcol=basic[bminpos];
140 | 
141 |     /*** Determining the incoming column ***/
142 |     for(i=0;i<M;i++)
143 |       maxratio[i]=INFINITY;
144 | 
145 |     for(i=0;i<constraint+countmaxzterms;i++)
146 |     {
147 |       if(a[bminpos][i]==0)
148 |       {
149 |         maxratio[i]=INFINITY;
150 |         continue;
151 |       }
152 |       if(a[bminpos][i]>0)
153 |       {
154 |         maxratio[i]=INFINITY;
155 |         continue;
156 |       }
157 |       maxratio[i]=temp[i]/a[bminpos][i];
158 |     }
159 |     maximum(maxratio,&maxratiomaxpos,2*constraint);
160 |     incomingcol=maxratiomaxpos;
161 |     for(i=0;i<constraint+countmaxzterms;i++)
162 |       x[i]=0;
163 |     for(i=0;i<constraint;i++)
164 |     {
165 |       x[basic[i]]=b[i];
166 |       printf("x[%d]=%0.3g\n",basic[i]+1,b[i]);
167 |     }
168 |     printf("\n Other variables are non-basic, ie, 0.");
169 |     for(i=0;i<constraint;i++)
170 |       z=z+c[i]*x[i];
171 |     if(obj_type==1)
172 |       z *= (-1.0);
173 |     printf("Max(z) = %g",z);
174 |     printf("\nComing in variable = X%d\t",incomingcol+1);
175 |     printf("Going out variable = X%d\n",gooutcol+1);
176 | 
177 |     /*** Changing the basic and non-basic variable ***/
178 | 
179 |     basic[bminpos]=incomingcol;
180 | 
181 |     /*** Performing the operations to bring similar expressions in
182 |     in-coming variable as out-going variable by row operations ***/
183 | 
184 |     key=a[bminpos][incomingcol];
185 |     b[bminpos]=b[bminpos]/key;
186 |     for(i=0;i<constraint+countmaxzterms;i++)
187 |       a[bminpos][i]=a[bminpos][i]/key;
188 |     for(i=0;i<constraint;i++)
189 |     {
190 |       if(bminpos==i)
191 |         continue;
192 |       key=a[i][incomingcol];
193 |       for(j=0;j<(constraint+countmaxzterms);j++)
194 |         a[i][j]=a[i][j]-a[bminpos][j]*key;
195 |       b[i]=b[i]-b[bminpos]*key;
196 |     }
197 |     
198 | 
199 |   }while(flag==0);
200 | 
201 |   printf("\nPress any key to exit...\n");
202 |   
203 | }
204 | void calctemp(float *temp,float a[N][M],float c[M],int basic[N])
205 | {
206 |   int i,j;
207 |   for(i=0;i<constraint+countmaxzterms;i++)
208 |   {
209 |     temp[i]=0;
210 |     for(j=0;j<constraint;j++)
211 |       temp[i]=temp[i]+c[basic[j]]*a[j][i];
212 |     temp[i]=temp[i]-c[i];
213 |   }
214 | }
215 | void maximum(float *arr,int *arrmaxpos, int n)
216 | {
217 |   int i;
218 |   int arrmax;
219 |   arrmax=arr[0];
220 |   *arrmaxpos=0;
221 |   for(i=0;i<n;i++)
222 |     if(arr[i]>arrmax)
223 |     {
224 |       arrmax=arr[i];
225 |       *arrmaxpos=i;
226 |     }
227 | }
228 | 
229 | void minimum(float *arr,int *arrminpos, int n)
230 | {
231 |   int i;
232 |   int arrmin;
233 |   arrmin=arr[0];
234 |   *arrminpos=0;
235 |   for(i=0;i<n;i++)
236 |     if(arr[i]<arrmin)
237 |     {
238 |       arrmin=arr[i];
239 |       *arrminpos=i;
240 |     }
241 | }
242 | void display (float c[N],float b[N],float a[N][M],int basic[N])
243 | {
244 |   int i,j;
245 |   displayframe(c);
246 |   for(i=0;i<constraint;i++)
247 |   {
248 |     printf("\n%0.3g\tX%d\t%0.3g\t",c[basic[i]],basic[i]+1,b[i]);
249 |     for(j=0;j<constraint+countmaxzterms;j++)
250 |       printf("%0.3g\t",a[i][j]);
251 |     printf("\n");
252 |   }
253 | }
254 | void displayframe(float c[M])
255 | {
256 |   int i;
257 |   printf("\t\tc[j]\t");
258 |   for(i=0;i<constraint+countmaxzterms;i++)
259 |     printf("%0.2g\t",c[i]);
260 |   printf("\n");
261 |   printf("\nc[B]\tB\tb\t");
262 |   for(i=0;i<constraint+countmaxzterms;i++)
263 |     printf("a[%d]\t",i+1);
264 |   printf("\n");
265 | }


--------------------------------------------------------------------------------
/day6/dual_simplex.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day6/dual_simplex.c.out


--------------------------------------------------------------------------------
/day6/revised_simplex.c:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<iomanip>
  3 | 
  4 | #define MAX 5
  5 | #define FORN(i,n) for(int i=0;i<n;i++)
  6 | 
  7 | using namespace std;
  8 | 
  9 | float cb[MAX]={0,0,0},cnb[MAX]={5,5,6};
 10 | int m = 3; // Number of variables
 11 | //float b1[MAX][MAX];
 12 | 
 13 | int copy(float a[][MAX], float b[][MAX]){
 14 |     FORN(i,MAX)
 15 |         FORN(j,MAX)
 16 |             a[i][j] = b[i][j];
 17 | }
 18 | 
 19 | void initialize_unity(float b[][MAX]){
 20 |     FORN(i,MAX)
 21 |         b[i][i] = 1.0;
 22 | }
 23 | 
 24 | void print_matrix(float b[][MAX], int n, int m=0){
 25 |     if (m==0) m=n;
 26 | 
 27 |     FORN(i, n){
 28 |         FORN(j, m)
 29 |             cout<<setw(7)<<setprecision(3)<<std::setfill(' ')<<b[i][j];
 30 |         cout<<endl;
 31 |     }
 32 | }
 33 | 
 34 | void print_vector(float b[MAX], int n){
 35 |     cout<<"[ ";
 36 |     FORN(i, n){
 37 |         cout<<setw(7)<<setprecision(3)<<std::setfill(' ')<<b[i]<<" ";
 38 |     }
 39 |     cout<<"] "<<endl;
 40 | }
 41 | 
 42 | void swap(float &a, float &b){
 43 |     float temp = a;
 44 |     a = b;
 45 |     b = temp;
 46 | }
 47 | 
 48 | 
 49 | int calculate(float b[][MAX], float bi[][MAX], float b1[][MAX] ,float c[MAX], int n){
 50 | 
 51 |     FORN(aa,5){
 52 | 
 53 |         float eita[MAX], e[MAX];
 54 | 
 55 |         float x[MAX] = {0};
 56 |         float y[MAX] = {0}, zc[MAX] = {0};
 57 |         float z=0;
 58 |         float alpha_temp[MAX] = {0};
 59 | 
 60 |         FORN(i, n)
 61 |             FORN(j, n)
 62 |                 x[i] += bi[i][j] * c[j];
 63 | 
 64 |         z = 0;
 65 |         FORN (i,n)
 66 |             z += cb[i]*x[i];
 67 | 
 68 | 
 69 |         cout<<"z:    ";
 70 |         cout<<z<<endl;
 71 |         cout<<"x: ";
 72 |         print_vector(x,n);
 73 | 
 74 | 
 75 |         FORN (i, n)
 76 |             FORN (j, n)
 77 |                 y[i] += cb[j] * bi[j][i];
 78 | 
 79 |         FORN (i, m){
 80 |             FORN (j, n)
 81 |                 zc[i] += y[j] * b1[j][i];
 82 |             zc[i] -= cnb[i];
 83 |         }
 84 | 
 85 |         float min = 0;
 86 |         int min_index = -1;
 87 |         FORN(i, m){
 88 |             if (zc[i]<min) 
 89 |                 min=zc[i],min_index=i;
 90 |         }
 91 | 
 92 |         int q = min_index; // Entering variable
 93 | 
 94 |         FORN(i,n){
 95 |             FORN(j,n)
 96 |                 alpha_temp[i] += bi[i][j] * b1[j][min_index];
 97 |             alpha_temp[i] = x[i] / alpha_temp[i];
 98 |         }
 99 | 
100 |         min = 99999;
101 |         min_index = -1;
102 |         
103 |         FORN(i, n){
104 |             if (alpha_temp[i]<min) 
105 |                 min=alpha_temp[i],min_index=i;
106 |         }
107 | 
108 | 
109 |         if (min_index<0) return 0;
110 |         int r = min_index; //leaving variable
111 | 
112 | 
113 |         float E[MAX][MAX] = {0};
114 |         float btemp[MAX][MAX];
115 | 
116 |         // Calculating e
117 |         FORN(j,n){
118 |             e[j] = 0;
119 |             FORN(k,n){
120 |                 e[j] += bi[j][k]*b1[k][q];
121 |             }
122 |         }
123 | 
124 |         // Calculating eita
125 |         FORN(j,n){
126 |             if (j==r)
127 |                 eita[j] = 1/e[r];
128 |             else
129 |                 eita[j] = -e[j]/e[r];
130 |         }
131 | 
132 | 
133 |         initialize_unity(E);
134 | 
135 |         FORN(i,n){
136 |             float t = b[i][r];
137 |             b[i][r] = b1[i][q];
138 |             b1[i][q] = t;
139 |             E[i][r] = eita[i];
140 |         }
141 | 
142 |         swap(cb[r],cnb[q]);
143 | 
144 |         FORN(i,n)
145 |             FORN(j,n){
146 |                 btemp[i][j] = 0;
147 |                 FORN(k,n){
148 |                     btemp[i][j] += E[i][k] * bi[k][j];
149 |                 }
150 |             }
151 | 
152 | 
153 |         cout<<"Basic : "<<endl;
154 |         print_matrix(b,n);
155 |         cout<<"Basic Inverse: "<<endl;
156 |         print_matrix(btemp,n);
157 | 
158 |         cout<<"\n";
159 | 
160 | 
161 |         copy(bi, btemp);
162 |         }
163 | }
164 | /*
165 | void input(){
166 |     string inequality;
167 |     printf("Enter no of variables\n");
168 |     scanf("%d",&var);
169 | 
170 |     printf("Enter no. of equations\n");
171 |     scanf("%d",&eqn);
172 | 
173 |     for(i = 0 ; i < eqn ; i++)
174 |     {
175 |         printf("Input equations #%d \n" , i + 1);
176 |         for(j = 0 ; j < var+1 ; j++)
177 |         {
178 |             scanf("%f",&mat[i][j]);
179 |                         
180 |         }
181 |         //cin >> inequality;
182 |         //if (inequality.at(0) == '<')
183 |         //{
184 |              slackVar++;
185 |              scanf("%f", &mat[i][j]);
186 |         }
187 |         //else if (inequality.at(0) == '>')
188 |         //{
189 |          // Can be extended for Big-M Method
190 |         //}
191 |                 
192 |         }
193 | 
194 | }
195 | */
196 | int main(){
197 | 
198 |     float b[MAX][MAX]={0};
199 |     float bi[MAX][MAX];
200 |     // float b1[MAX][MAX] = {{3,2,3,1},{3,0,1,2},{1,3,0,2}};
201 |     // float c[MAX] = {200,180,160,50};
202 |     float b1[MAX][MAX] = {{-2,3,0,5},{-2,-1,1,-2},{1,0,3,3}};
203 |     float c[MAX] = {-2,3,3,0};
204 | 
205 |     int n = 3;
206 | 
207 |     initialize_unity(b);
208 |     copy(bi,b);
209 | 
210 |     calculate(b,bi,b1,c,n);
211 | 
212 |     return 0;
213 | }


--------------------------------------------------------------------------------
/day6/revised_simplex.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day6/revised_simplex.c.out


--------------------------------------------------------------------------------
/day7/2phase_simplex.c:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <iomanip> 
  3 | #include <vector>
  4 | 
  5 | using namespace std;
  6 | 
  7 | int min_index(float *lastrow, int length)
  8 | {
  9 |     int index=0;
 10 |     for (int i=1; i<length; i++)
 11 |     {
 12 |         if (lastrow[i]<lastrow[index])
 13 |             index=i;
 14 |     }
 15 |     if (lastrow[index]>=0)
 16 |         return -1;
 17 |     else
 18 |         return index;
 19 | }
 20 | 
 21 | int min_col_index(float *temp, int length)
 22 | {
 23 |     int index=0;
 24 |     for (int i=1; i<length; i++)
 25 |     {
 26 |         if (temp[i]<temp[index])
 27 |             index=i;
 28 |     }
 29 |     return index;
 30 | }
 31 | 
 32 | void print(int n, int m, float **A)
 33 | {
 34 |     int i, j;
 35 |     cout<<endl<<endl;
 36 |     for (i=0; i<m; i++){
 37 |         for (j=0; j<(n); j++)
 38 |             cout<<setw(10)<<setprecision(5)<<A[i][j];
 39 |         cout<<endl;
 40 |     }
 41 |     // cout<<"----------------"<<endl;
 42 | }
 43 | 
 44 | void simplex(float **activeA, int n, int m, int *index, int max_min)
 45 | {
 46 |     float lastrow[n+1], *temp;
 47 |     int i, j, pivot_col=0, pivot_row, count;
 48 |     bool stop=true, unbounded=false;
 49 | 
 50 |     for (i=0; i<n; i++)
 51 |     {
 52 |         if (activeA[m][i]<=0)
 53 |             stop=false;
 54 | 
 55 |     }
 56 | 
 57 |     if (stop==true){
 58 |         if (max_min==1)
 59 |             cout<<endl<<"Optimal Solution is "<<activeA[m][n]<<endl;
 60 |         if (max_min==2)
 61 |             cout<<endl<<"Optimal Solution is "<<(-1)*activeA[m][n]<<endl;
 62 |         
 63 |         float *sol_;
 64 |         sol_ = new float [n];
 65 |         for (i=0; i<m; i++)
 66 |         {
 67 |             if (index[i]>=0)
 68 |                 sol_[index[i]]=activeA[i][n];
 69 |         }
 70 |         for (i=0; i<n; i++)
 71 |         {
 72 |             cout<<"x"<<i+1<<" is "<<sol_[i]<<endl;
 73 |         }
 74 |         return;
 75 |     }
 76 | 
 77 |     pivot_col=min_index(activeA[m], n);
 78 | 
 79 |     //If the last element corresponding to pivot choosen pivot col is zero, Alternate solution exists.
 80 |     if (activeA[m][pivot_col]==0)
 81 |     {
 82 |         if (max_min==1)
 83 |             cout<<endl<<"Alternate Solution Exists. Optimal Solution is "<<activeA[m][n]<<endl;
 84 |         if (max_min==2)
 85 |             cout<<endl<<"Alternate Solution Exists. Optimal Solution is "<<(-1)*activeA[m][n]<<endl;
 86 |         float *sol_;
 87 |         sol_ = new float [n];
 88 |         for (i=0; i<m; i++)
 89 |         {
 90 |             if (index[i]>=0)
 91 |                 sol_[index[i]]=activeA[i][n];
 92 |         }
 93 |         for (i=0; i<n; i++)
 94 |         {
 95 |             cout<<"x"<<i+1<<" is "<<sol_[i]<<endl;
 96 |         }
 97 |         return;
 98 |     }
 99 | 
100 | 
101 |     //Unboundedness Checking
102 |     count=0;
103 |     for (i=0; i<m; i++)
104 |     {
105 |         if (activeA[i][pivot_col]<=0)
106 |             count++;
107 |     }
108 |     if (count==m){
109 |         cout<<"Solution is Unbounded"<<endl;
110 |         return;
111 |     }
112 | 
113 |     //creating temp array for choosing pivot_row
114 |     temp=new float [m];
115 |     for (i=0; i<m; i++)
116 |     {
117 |         if (activeA[i][pivot_col]>0)
118 |             temp[i]=activeA[i][n]/activeA[i][pivot_col];
119 |         else
120 |             temp[i]=1000000;
121 |     }
122 |     pivot_row=min_col_index(temp, m);
123 |     cout<<"Row Column"<<pivot_row<<"  "<<pivot_col<<endl;
124 | 
125 |     index[pivot_row]=pivot_col;
126 |     float swap;
127 |     swap=activeA[m+2][pivot_col];
128 |     activeA[m+2][pivot_col]=activeA[pivot_row][n+1];
129 |     activeA[pivot_row][n+1]=swap;
130 | 
131 |     //make new table
132 |     float pivot=activeA[pivot_row][pivot_col];
133 |     for (i=0; i<=m+1; i++)
134 |     {
135 |         for(j=0; j<=n; j++)
136 |         {
137 |             if (i!= pivot_row && j!= pivot_col)
138 |             {
139 |                 activeA[i][j]=(activeA[i][j]*activeA[pivot_row][pivot_col]-activeA[pivot_row][j]*activeA[i][pivot_col])/activeA[pivot_row][pivot_col];
140 |             }
141 |         }
142 |     }
143 | 
144 |     for (i=0; i<=n; i++)
145 |         activeA[pivot_row][i]=activeA[pivot_row][i]/pivot;
146 | 
147 |     for (i=0; i<=m+1; i++)
148 |         activeA[i][pivot_col]=-activeA[i][pivot_col]/pivot;
149 |     activeA[pivot_row][pivot_col]=1/pivot;
150 |     
151 |     print(n+1, m+1, activeA);
152 | 
153 |     simplex(activeA, n, m, index, max_min);
154 | }
155 | 
156 | 
157 | int main()
158 | {
159 |     int n, m, i, j, *sol_index, geq, leq, eq, M=1000, max_min;
160 |     float **A, *b, **activeA, *z, temp;
161 | 
162 |     cout<<"Enter No of Equations (m) : ";
163 |     cin>>m;
164 | 
165 |     cout<<"Enter No of Unknwons (n) : ";
166 |     cin>>n;
167 | 
168 |     cout<<"Enter the number of >=, =, <= contraints : "<<endl;
169 |     cin>>geq>>eq>>leq;
170 | 
171 |     if (geq==0 && eq==0)
172 |         M=0;
173 | 
174 |     A= new float* [m]; 
175 |     activeA = new float* [m+1+1+1];
176 | 
177 |     for (i=0; i<m; i++){
178 |         A[i]= new float [n];
179 |         activeA[i]= new float [n+geq+1+1];
180 |     }
181 |     activeA[m]= new float [n+geq+1];
182 |     activeA[m+1]= new float [n+geq+1];
183 |     activeA[m+2]= new float [n+geq+1];
184 | 
185 |     cout<<"Enter the matrix A in order : \n";
186 |     for (i=0; i<m; i++){
187 |         for (j=0; j<n; j++){
188 |             cin>>A[i][j];
189 |             activeA[i][j]=A[i][j];
190 |         }
191 |     }
192 | 
193 |     for (i=0; i<geq; i++)
194 |     {
195 |         for (j=0; j<m; j++){
196 |             if (i==j)
197 |                 activeA[j][n+i]=-1;
198 |             else
199 |                 activeA[j][n+i]=0;
200 |         }
201 |     }
202 | 
203 |     cout<<"Enter the column vector B in same order as A : \n";
204 |     b=new float [m];
205 |     for (i=0; i<m; i++){
206 |         cin>>b[i];
207 |         activeA[i][n+geq]=b[i];
208 |     }
209 | 
210 |     for (i=0; i<geq+eq; i++)
211 |     {
212 |         for (j=0; j<n+geq+1; j++)
213 |             activeA[m][j]-=activeA[i][j];
214 |     }
215 | 
216 |     for (i=0; i<n+geq; i++)
217 |     {
218 |         activeA[m+2][i]=i;
219 |     }
220 | 
221 |     for (i=0; i<m; i++)
222 |     {
223 |         activeA[i][n+geq+1]=50+i;
224 |     }
225 | 
226 |     cout<<"Enter the choice : "<<endl<<"(1) Maximize, (2) Minimize"<<endl<<"Enter your choice : ";
227 |     cin>>max_min;
228 | 
229 |     cout<<"Enter the objective function z :\n";
230 |     z=new float [n];
231 |     for (i=0; i<n; i++){
232 |         cin>>z[i];
233 |         if (max_min==1)
234 |             activeA[m+1][i]=-z[i];
235 |         if (max_min==2)
236 |             activeA[m+1][i]=z[i];
237 |     }
238 | 
239 |     sol_index = new int[m];
240 | 
241 |     for (i=0; i<m; i++)
242 |         sol_index[i]=-1;
243 | 
244 |     print(n+geq+1, m+1, activeA);
245 |     cout<<"Phase I starts"<<endl;
246 |     simplex(activeA, n+geq, m, sol_index, max_min);
247 | 
248 |     cout<<"Phase I complete"<<endl;
249 | 
250 |     for (i=0; i<=n+geq; i++)
251 |         activeA[m][i]=activeA[m+1][i];
252 | 
253 |     for (i=0; i<n+geq; i++)
254 |     {
255 |         if (activeA[m+2][i]>=50)
256 |         {
257 |             for (j=0; j<m+2; j++)
258 |                 activeA[j][i]=0;
259 |         }
260 |     }
261 | 
262 |     simplex(activeA, n+geq, m, sol_index, max_min);
263 | 
264 | 
265 | 
266 |     return 0;
267 | 
268 | 
269 | }


--------------------------------------------------------------------------------
/day7/2phase_simplex.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day7/2phase_simplex.c.out


--------------------------------------------------------------------------------
/day7/Lab on Two phase Simplex.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day7/Lab on Two phase Simplex.pdf


--------------------------------------------------------------------------------
/day8/Class 8 (14.03.17).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day8/Class 8 (14.03.17).pdf


--------------------------------------------------------------------------------
/day8/branch&bound.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<conio.h>
 3 | #include<stdlib.h>
 4 | 
 5 | int a[10][10],visited[10],n,cost=0;
 6 | 
 7 | void get()
 8 | {
 9 |   int i,j;
10 |   printf("\n\nEnter Number of Cities: ");
11 |   scanf("%d",&n);
12 |   printf("\nEnter Cost Matrix: \n");
13 |   for( i=0;i<n;i++)
14 |   {
15 |     printf("\n Enter Elements of Row # : %d\n",i+1);
16 |     for( j=0;j<n;j++)
17 |     scanf("%d",&a[i][j]);
18 |     visited[i]=0;
19 |   }
20 | 
21 |   printf("\n\nThe Cost Matrix is:\n");
22 |   for( i=0;i<n;i++)
23 |   {
24 |     printf("\n\n");
25 |     for( j=0;j<n;j++)
26 |       printf("\t%d",a[i][j]);
27 |   }         
28 | }
29 | 
30 | void mincost(int city)
31 | {
32 |   int i,ncity;
33 |   visited[city]=1;
34 |   printf("%d ===> ",city+1);
35 |   ncity=least(city);
36 | 
37 |   if(ncity==999)
38 |   {
39 |     ncity=0;
40 |     printf("%d",ncity+1);
41 |     cost+=a[city][ncity];
42 |     return;
43 |   }
44 | 
45 |   mincost(ncity);
46 | }
47 | 
48 | int least(int c)
49 | {
50 |   int i,nc=999;
51 |   int min=999,kmin;
52 |   for(i=0;i<n;i++)
53 |   {
54 |     if((a[c][i]!=0)&&(visited[i]==0))
55 |     {
56 |       if(a[c][i]<min)
57 |       {
58 |         min=a[i][0]+a[c][i];
59 |         kmin=a[c][i];
60 |         nc=i;
61 |       }
62 |     }
63 |   }
64 | 
65 |   if(min!=999)
66 |     cost+=kmin;
67 |   return nc;
68 | }
69 | 
70 | void put()
71 | {
72 |   printf("\n\nMinimum cost:");
73 |   printf("%d",cost);
74 | }
75 | 
76 | int main()
77 | {
78 |   get();
79 |   printf("\n\nThe Path is:\n\n");
80 |   mincost(0);
81 |   put();
82 |   getch();
83 | }


--------------------------------------------------------------------------------
/day8/cutting_plane.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cmath>
  3 | using namespace std;
  4 | 
  5 | int d[10]={0};
  6 | int dmap[10]={-1};
  7 | float mat[10][10], b[10], temp[10][10], constants[10];
  8 | float ans[10][10], z[10];
  9 | int R, C;
 10 | 
 11 | int duald[10]={0};
 12 | int dualdmap[10]={-1};
 13 | float dualmat[10][10], dualb[10], dualtemp[10][10], dualconstants[10];
 14 | float dualans[10][10], dualz[10];
 15 | int dualR, dualC;
 16 | 
 17 | int main()
 18 | {
 19 | 	int in_var, eqn, var;
 20 | 	int flag = 0;int incos=0;
 21 | 	string inequality;
 22 | 	cout << "Enter no of variables\n";
 23 | 	cin >> in_var;
 24 | 	var= in_var;
 25 | 	cout << "Enter no. of equations\n";
 26 | 	cin >> eqn;
 27 | 	for(int i = 0 ; i < eqn ; i++)
 28 | 	{
 29 | 		cout << "Enter coefficients and constant term of equation no " << i+1 << " seperated by spaces:\n";
 30 | 		for(int j = 0 ; j <= in_var ; j++)
 31 | 		{
 32 | 			cin >> mat[i][j];
 33 | 		}
 34 | 
 35 | 	}
 36 | 	
 37 | 	for(int i=0;i < eqn;i++)
 38 | 	{
 39 | 		for(int j=0;j<=in_var;j++)
 40 | 		{
 41 | 			temp[i][j] = mat[i][j];
 42 | 		}
 43 | 	}
 44 | 	
 45 | 	cout << "Enter the objective function to be maximised\n";
 46 | 	for(int i=0;i<=in_var;i++)
 47 | 	{
 48 | 		int a=0;
 49 | 		cin >> a;
 50 | 		if(a>0)flag=1;
 51 | 		temp[eqn][i] = -a;
 52 | 	}
 53 | 	
 54 | 	cout << "\nInitial simplex table\n ";
 55 | 	for(int i=0;i <= eqn;i++)
 56 | 	{
 57 | 		for(int j=0;j<=in_var;j++)
 58 | 		{
 59 | 			cout << " " << temp[i][j];
 60 | 		}
 61 | 		cout << endl;
 62 | 	}
 63 | 	int dummy=1;
 64 | 	cout << "\n Flag is " << flag;
 65 | 	while(flag){
 66 | 		
 67 | 		float min = 10000; int prod=0;
 68 | 		int minpos = -1;
 69 | 		for(int i=0;i<in_var;i++)
 70 | 		{
 71 | 			if(temp[eqn][i] < 0)prod=1;
 72 | 		}
 73 | 		if(!prod){
 74 | 			cout << "Prod is " << prod;
 75 | 			flag=0;
 76 | 			break;
 77 | 		}
 78 | 				
 79 | 		for(int i=0;i<in_var;i++)
 80 | 		{
 81 | 			if(temp[eqn][i] <= min)
 82 | 			{
 83 | 				min = temp[eqn][i];
 84 | 				minpos = i;
 85 | 			}
 86 | 		}
 87 | 		
 88 | 		cout << "\n Value of minpos is " << minpos << "  and incoming variable is  " << in_var << endl;
 89 | 		int pivot = -1;
 90 | 		float minp = 10000;
 91 | 		for(int i=0;i< eqn;i++)
 92 | 		{
 93 | 			if(1.0*temp[i][in_var]/temp[i][minpos] < minp && 1.0*temp[i][in_var]/temp[i][minpos]>0)
 94 | 			{
 95 | 				minp = 1.0*temp[i][in_var]/temp[i][minpos];
 96 | 				pivot = i;
 97 | 			}
 98 | 		}
 99 | 		
100 | 		if(pivot==-1){
101 | 			flag=0;
102 | 			incos = 1;
103 | 			break;
104 | 		}
105 | 		cout << "\n Pivot : " << temp[pivot][minpos] << " at pos " << pivot;
106 | 		cout << "\n Most negative element " << min;
107 | 		
108 | 		d[minpos] = 1;
109 | 		dmap[minpos] = pivot;
110 | 		float p = temp[pivot][minpos];
111 | 		
112 | 		for(int i=0;i<=eqn;i++)
113 | 		{
114 | 			for(int j=0;j<=in_var;j++)
115 | 			{
116 | 				if(i==pivot || j==minpos)continue;
117 | 				temp[i][j] = temp[i][j] - 1.0*temp[pivot][j]*temp[i][minpos]/p;
118 | 			}
119 | 		}
120 | 
121 | 		for(int i=0;i<=eqn; i++)
122 | 		{
123 | 			if(i==pivot)continue;
124 | 			temp[i][minpos] = -temp[i][minpos]/p;
125 | 		}
126 | 		for(int j=0;j<=in_var;j++)
127 | 		{
128 | 			if(j==minpos)continue;
129 | 			temp[pivot][j] = temp[pivot][j]/p;
130 | 		}
131 | 		temp[pivot][minpos] = 1.0/temp[pivot][minpos];
132 | 
133 | 		
134 | 		
135 | 		cout << "\n Simplex table\n ";
136 | 		for(int i=0;i <= eqn;i++)
137 | 		{
138 | 			for(int j=0;j<=in_var;j++)
139 | 			{
140 | 				cout <<temp[i][j] << " ";
141 | 			}
142 | 			cout << endl;
143 | 		}
144 | 	}
145 | 
146 | 	if(incos)
147 | 	{
148 | 		cout << "\n\n The given system of equations inconsistent  ";
149 | 		return 0;
150 | 	}
151 | 
152 | 	for(int j=0;j<in_var;j++)
153 | 	{
154 | 		if(temp[eqn][j]==0)
155 | 		{
156 | 			cout << "\n\n However infinite solutions exist for this case ";
157 | 			break;
158 | 		}
159 | 	}
160 | 	
161 | 	bool flagdual = true;
162 | 	while(flagdual){
163 | 
164 | 		bool ifc=true;
165 | 		for(int i=0;i < eqn;i++)
166 | 		{
167 | 			if(fabs(floor(temp[i][in_var])-temp[i][in_var])>1e-5){
168 | 				ifc = false;break;
169 | 			}
170 | 		}
171 | 		if(ifc){flagdual=false;break;}
172 | 		float xbmax=-1; int xbpos;
173 | 		for(int i=0;i < eqn;i++)
174 | 		{
175 | 			for(int j=0;j<=in_var;j++)
176 | 			{
177 | 				dualtemp[i][j] = temp[i][j];
178 | 				if(j==in_var && fabs(floor(temp[i][j])-temp[i][j])>1e-5){
179 | 					if((temp[i][j]-floor(temp[i][j])) > xbmax){
180 | 						xbmax = temp[i][j]-floor(temp[i][j]);
181 | 						xbpos = i;
182 | 					}
183 | 				}
184 | 			}
185 | 		}
186 | 		cout << "\nvalue of xbmax: " << xbmax << endl;
187 | 		if((int)xbmax==-1 || fabs(xbmax-1)<1e-5){cout << "\n"<<endl;return 0;}
188 | 		cout << "\n value of xbpos : " << xbpos;
189 | 		for(int j=0;j<=in_var;j++){
190 | 			dualtemp[eqn][j] = floor(temp[xbpos][j]) - temp[xbpos][j];
191 | 			dualtemp[eqn+1][j] = temp[eqn][j];
192 | 		}
193 | 		eqn = eqn +1;
194 | 
195 | 		cout << "\nPrinting in-between table: \n";
196 | 		for(int i=0;i <= eqn;i++)
197 | 		{
198 | 			for(int j=0;j<=in_var;j++)
199 | 			{
200 | 				cout << dualtemp[i][j] << " " ;
201 | 			}
202 | 			cout << endl;
203 | 		}
204 | 	
205 | 		float min = 10000;int minpos = -1;
206 | 			int pivot = -1;
207 | 		
208 | 			for(int i=0;i< eqn;i++)
209 | 			{
210 | 				if(dualtemp[i][in_var] < min){
211 | 					min = dualtemp[i][in_var];
212 | 					pivot = i;
213 | 				}
214 | 			}
215 | 
216 | 		cout << "\n Value of pivot: " << pivot << endl;
217 | 			float minp = 10000;
218 | 		for(int j=0;j<in_var;j++){
219 | 			float f = 1.0*dualtemp[eqn][j]/dualtemp[pivot][j];
220 | 			cout << "\n Value f : " << fabs(f) << " ";
221 | 			if(fabs(f) < minp){minp = fabs(f);minpos = j;cout << " \n Minpos selected as: " << j << endl;}
222 | 		}
223 | 		float p = dualtemp[pivot][minpos];
224 | 		cout << "\n Value of minpos and p: " << minpos << " " << p << endl;
225 | 		for(int i=0;i<=eqn;i++)
226 | 			{
227 | 				for(int j=0;j<=in_var;j++)
228 | 				{
229 | 					if(i==pivot || j==minpos)continue;
230 | 					dualtemp[i][j] = dualtemp[i][j] - 1.0*dualtemp[pivot][j]*dualtemp[i][minpos]/p;
231 | 				}
232 | 			}
233 | 
234 | 		for(int i=0;i<=eqn; i++)
235 | 			{
236 | 				if(i==pivot)continue;
237 | 				dualtemp[i][minpos] = -dualtemp[i][minpos]/p;
238 | 			}
239 | 			for(int j=0;j<=in_var;j++)
240 | 			{
241 | 				if(j==minpos)continue;
242 | 				dualtemp[pivot][j] = dualtemp[pivot][j]/p;
243 | 			}
244 | 			dualtemp[pivot][minpos] = 1.0/dualtemp[pivot][minpos];
245 | 
246 | 		for(int i=0;i <= eqn;i++)
247 | 			{
248 | 				for(int j=0;j<=in_var;j++)
249 | 				{
250 | 					cout <<dualtemp[i][j] << " ";
251 | 					temp[i][j] = dualtemp[i][j];
252 | 				}
253 | 				cout << endl;
254 | 			}
255 | 	}
256 | 	return 0;
257 | }
258 | 


--------------------------------------------------------------------------------
/day8/cutting_plane.cpp.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day8/cutting_plane.cpp.out


--------------------------------------------------------------------------------
/day8/day8.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day8/day8.pdf


--------------------------------------------------------------------------------
/day9/question.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day9/question.pdf


--------------------------------------------------------------------------------
/day9/transport.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main()
 4 | {
 5 | 	int flag=0,flag1=0;
 6 | 	int s[10],d[10],sn,eop=1,dm,a[10][10];
 7 | 	int i,j,sum=0,min,x[10][10],k,fa,fb;
 8 | 	printf("Enter the number of supplies : ");
 9 | 	scanf("%d",&sn);
10 | 	printf("Enter the number of demands : ");
11 | 	scanf("%d",&dm);
12 | 	printf("Enter the supply values : \n");
13 | 	for(i=0;i<sn;i++)
14 | 	scanf("%d",&s[i]);
15 | 	printf("Enter the demand values \n");
16 | 	for(j=0;j<sn;j++)
17 | 	scanf("%d",&d[j]);
18 | 	printf("Enter the cost matrix \n");
19 | 	for(i=0;i<sn;i++)
20 | 	{
21 | 		for(j=0;j<dm;j++)
22 | 		{
23 | 			scanf("%d",&a[i][j]);
24 | 		}
25 | 	}
26 | 	i=0;
27 | 	j=0;
28 | 	for(i=0,j=0;i<sn,j<dm;)
29 | 	{
30 | 		if(s[i]<d[j])          
31 | 		{
32 | 			x[i][j]=a[i][j]*s[i];
33 | 			d[j]=d[j]-s[i];
34 | 			i++;
35 | 		}
36 | 		else if(s[i]>=d[j])
37 | 		{
38 | 			x[i][j]=a[i][j]*d[j];
39 | 			s[i]=s[i]-d[j];
40 | 			j++;
41 | 		}
42 | 	}
43 | 	printf("\n\n Given cost matrix is :");
44 | 	for(fa=0;fa<sn;fa++)
45 | 	{
46 | 		printf("\n");
47 | 		for(fb=0;fb<dm;fb++)
48 | 		{
49 | 			printf("%d ",a[fa][fb]);
50 | 		}
51 | 	}
52 | 	printf("\n\n Allocated cost matrix is : ");
53 | 	for(fa=0;fa<sn;fa++)
54 | 	{
55 | 		printf("\n");
56 | 		for(fb=0;fb<dm;fb++)
57 | 		{
58 | 			printf("%d ",x[fa][fb]);
59 | 			sum=sum+x[fa][fb];
60 | 		}
61 | 	}
62 | 	printf("\n\nThe transportation cost is : %d",sum);
63 | 	return(0);
64 | }


--------------------------------------------------------------------------------
/day9/transport.c.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day9/transport.c.out


--------------------------------------------------------------------------------
/day9/transport.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/day9/transport.pdf


--------------------------------------------------------------------------------
/index.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/athityakumar/or_lab/83b7a79292e0d545aff6b594f906397e2f197f27/index.pdf


--------------------------------------------------------------------------------
/or_lab.sh:
--------------------------------------------------------------------------------
 1 | # Hack to run c / c++ files with 1 command like Python / Ruby
 2 | # Like `or_c filename.c` or `or_cpp filename.cpp`
 3 | function or_c {
 4 | gcc $1 -o $1.out -std=c99
 5 | ./$1.out
 6 | ls
 7 | }
 8 | 
 9 | function or_cpp {
10 | g++ $1 -o $1.out
11 | ./$1.out
12 | ls
13 | }
14 | 
15 | # Hack to push all files to git with 1 command.
16 | function or_push {
17 | cd $OR_LAB_REPO_PATH
18 | git add -A
19 | git commit -a -m "Deployed by bash : $1"
20 | git push origin master
21 | ls
22 | }
23 | 
24 | # Hack to pull all files to git with 1 command. Assumes no merge conflictss. Dies otherwise.
25 | function or_pull {
26 | cd $OR_LAB_REPO_PATH
27 | git add -A
28 | git stash
29 | git pull origin master
30 | }
31 | 
32 | # Too lazy to type 6 extra characters
33 | function or_cd {
34 | cd $OR_LAB_REPO_PATH
35 | }
36 | 
37 | # Hack : cd = cd + ls
38 | function cd {
39 | builtin cd $1
40 | ls
41 | }


--------------------------------------------------------------------------------