diff --git a/AfterPreProcessing.txt b/AfterPreProcessing.txt
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..bb11d391fba2fdab6717d6591c92d83d9920eb46 100644
--- a/AfterPreProcessing.txt
+++ b/AfterPreProcessing.txt
@@ -0,0 +1,122 @@
+\ SCIP STATISTICS
+\ Problem name : data/6f4s.lp_relaxscip
+\ Variables : 54 (54 binary, 0 integer, 0 implicit integer, 0 continuous)
+\ Constraints : 36
+Minimize
+ Obj: +1 t_x_{1}_{0} +15 t_x_{1}_{15} +30 t_x_{1}_{30} +45 t_x_{1}_{45} +60 t_x_{1}_{60} +75 t_x_{1}_{75}
+ +90 t_x_{1}_{90} +105 t_x_{1}_{105} +120 t_x_{1}_{120} +15 t_x_{2}_{15} +30 t_x_{2}_{30} +45 t_x_{2}_{45}
+ +60 t_x_{2}_{60} +75 t_x_{2}_{75} +90 t_x_{2}_{90} +105 t_x_{2}_{105} +120 t_x_{2}_{120} +15 t_x_{3}_{15}
+ +30 t_x_{3}_{30} +45 t_x_{3}_{45} +60 t_x_{3}_{60} +75 t_x_{3}_{75} +90 t_x_{3}_{90} +105 t_x_{3}_{105}
+ +120 t_x_{3}_{120} +15 t_x_{4}_{15} +30 t_x_{4}_{30} +45 t_x_{4}_{45} +60 t_x_{4}_{60} +75 t_x_{4}_{75}
+ +90 t_x_{4}_{90} +105 t_x_{4}_{105} +120 t_x_{4}_{120} +15 t_x_{5}_{15} +30 t_x_{5}_{30} +45 t_x_{5}_{45}
+ +60 t_x_{5}_{60} +75 t_x_{5}_{75} +90 t_x_{5}_{90} +105 t_x_{5}_{105} +120 t_x_{5}_{120} +15 t_x_{6}_{15}
+ +30 t_x_{6}_{30} +45 t_x_{6}_{45} +60 t_x_{6}_{60} +75 t_x_{6}_{75} +90 t_x_{6}_{90} +105 t_x_{6}_{105}
+ +120 t_x_{6}_{120}
+Subject to
+ slot1: +1 t_x_{1}_{0} +1 t_x_{2}_{0} <= +1
+ slot2: +1 t_x_{1}_{15} +1 t_x_{2}_{15} <= +1
+ slot3: +1 t_x_{1}_{30} +1 t_x_{2}_{30} <= +1
+ slot4: +1 t_x_{1}_{45} +1 t_x_{2}_{45} <= +1
+ slot5: +1 t_x_{1}_{60} +1 t_x_{2}_{60} <= +1
+ slot6: +1 t_x_{1}_{75} +1 t_x_{2}_{75} <= +1
+ slot7: +1 t_x_{1}_{90} +1 t_x_{2}_{90} <= +1
+ slot8: +1 t_x_{1}_{105} +1 t_x_{2}_{105} <= +1
+ F_6: +1 t_x_{6}_{0} +1 t_x_{6}_{15} +1 t_x_{6}_{30} +1 t_x_{6}_{45} +1 t_x_{6}_{60} +1 t_x_{6}_{75} +1 t_x_{6}_{90}
+ +1 t_x_{6}_{105} +1 t_x_{6}_{120} = +1
+ slot10: +1 t_x_{2}_{0} +1 t_x_{3}_{0} +1 t_x_{4}_{0} <= +1
+ slot11: +1 t_x_{2}_{15} +1 t_x_{3}_{15} +1 t_x_{4}_{15} <= +1
+ slot12: +1 t_x_{2}_{30} +1 t_x_{3}_{30} +1 t_x_{4}_{30} <= +1
+ slot13: +1 t_x_{2}_{45} +1 t_x_{3}_{45} +1 t_x_{4}_{45} <= +1
+ slot14: +1 t_x_{2}_{60} +1 t_x_{3}_{60} +1 t_x_{4}_{60} <= +1
+ slot15: +1 t_x_{2}_{75} +1 t_x_{3}_{75} +1 t_x_{4}_{75} <= +1
+ slot16: +1 t_x_{2}_{90} +1 t_x_{3}_{90} +1 t_x_{4}_{90} <= +1
+ F_4: +1 t_x_{4}_{0} +1 t_x_{4}_{15} +1 t_x_{4}_{30} +1 t_x_{4}_{45} +1 t_x_{4}_{60} +1 t_x_{4}_{75} +1 t_x_{4}_{90}
+ +1 t_x_{4}_{105} +1 t_x_{4}_{120} = +1
+ F_2: +1 t_x_{2}_{0} +1 t_x_{2}_{15} +1 t_x_{2}_{30} +1 t_x_{2}_{45} +1 t_x_{2}_{60} +1 t_x_{2}_{75} +1 t_x_{2}_{90}
+ +1 t_x_{2}_{105} +1 t_x_{2}_{120} = +1
+ slot19: +1 t_x_{1}_{0} +1 t_x_{3}_{0} +1 t_x_{5}_{0} <= +1
+ slot20: +1 t_x_{1}_{15} +1 t_x_{3}_{15} +1 t_x_{5}_{15} <= +1
+ slot21: +1 t_x_{1}_{30} +1 t_x_{3}_{30} +1 t_x_{5}_{30} <= +1
+ slot22: +1 t_x_{1}_{45} +1 t_x_{3}_{45} +1 t_x_{5}_{45} <= +1
+ slot23: +1 t_x_{1}_{60} +1 t_x_{3}_{60} +1 t_x_{5}_{60} <= +1
+ slot24: +1 t_x_{1}_{75} +1 t_x_{3}_{75} +1 t_x_{5}_{75} <= +1
+ F_1: +1 t_x_{1}_{0} +1 t_x_{1}_{15} +1 t_x_{1}_{30} +1 t_x_{1}_{45} +1 t_x_{1}_{60} +1 t_x_{1}_{75} +1 t_x_{1}_{90}
+ +1 t_x_{1}_{105} +1 t_x_{1}_{120} = +1
+ F_3: +1 t_x_{3}_{0} +1 t_x_{3}_{15} +1 t_x_{3}_{30} +1 t_x_{3}_{45} +1 t_x_{3}_{60} +1 t_x_{3}_{75} +1 t_x_{3}_{90}
+ +1 t_x_{3}_{105} +1 t_x_{3}_{120} = +1
+ F_5: +1 t_x_{5}_{0} +1 t_x_{5}_{15} +1 t_x_{5}_{30} +1 t_x_{5}_{45} +1 t_x_{5}_{60} +1 t_x_{5}_{75} +1 t_x_{5}_{90}
+ +1 t_x_{5}_{105} +1 t_x_{5}_{120} = +1
+ slot28: +1 t_x_{4}_{0} +1 t_x_{5}_{0} +1 t_x_{6}_{0} <= +1
+ slot29: +1 t_x_{4}_{15} +1 t_x_{5}_{15} +1 t_x_{6}_{15} <= +1
+ slot30: +1 t_x_{4}_{30} +1 t_x_{5}_{30} +1 t_x_{6}_{30} <= +1
+ slot31: +1 t_x_{4}_{45} +1 t_x_{5}_{45} +1 t_x_{6}_{45} <= +1
+ slot32: +1 t_x_{4}_{60} +1 t_x_{5}_{60} +1 t_x_{6}_{60} <= +1
+ slot33: +1 t_x_{4}_{75} +1 t_x_{5}_{75} +1 t_x_{6}_{75} <= +1
+ slot35: +1 t_x_{4}_{105} +1 t_x_{5}_{105} +1 t_x_{6}_{105} <= +1
+ cf1_0: -1 t_x_{2}_{60} +1 t_x_{3}_{0} +1 t_x_{3}_{15} +1 t_x_{3}_{30} +1 t_x_{3}_{45} +1 t_x_{3}_{75}
+ >= +0
+ cf1_1: -1 t_x_{1}_{15} -1 t_x_{3}_{30} -1 t_x_{4}_{15} -1 t_x_{6}_{30} >= -3
+Bounds
+ 0 <= t_x_{1}_{0} <= 1
+ 0 <= t_x_{1}_{15} <= 1
+ 0 <= t_x_{1}_{30} <= 1
+ 0 <= t_x_{1}_{45} <= 1
+ 0 <= t_x_{1}_{60} <= 1
+ 0 <= t_x_{1}_{75} <= 0
+ 0 <= t_x_{1}_{90} <= 0
+ 0 <= t_x_{1}_{105} <= 0
+ 0 <= t_x_{1}_{120} <= 0
+ 0 <= t_x_{2}_{0} <= 1
+ 0 <= t_x_{2}_{15} <= 1
+ 0 <= t_x_{2}_{30} <= 1
+ 0 <= t_x_{2}_{45} <= 1
+ 0 <= t_x_{2}_{60} <= 1
+ 0 <= t_x_{2}_{75} <= 1
+ 0 <= t_x_{2}_{90} <= 0
+ 0 <= t_x_{2}_{105} <= 0
+ 0 <= t_x_{2}_{120} <= 0
+ 0 <= t_x_{3}_{0} <= 1
+ 0 <= t_x_{3}_{15} <= 1
+ 0 <= t_x_{3}_{30} <= 1
+ 0 <= t_x_{3}_{45} <= 1
+ 0 <= t_x_{3}_{60} <= 1
+ 0 <= t_x_{3}_{75} <= 1
+ 0 <= t_x_{3}_{90} <= 0
+ 0 <= t_x_{3}_{105} <= 0
+ 0 <= t_x_{3}_{120} <= 0
+ 0 <= t_x_{4}_{0} <= 1
+ 0 <= t_x_{4}_{15} <= 1
+ 0 <= t_x_{4}_{30} <= 1
+ 0 <= t_x_{4}_{45} <= 1
+ 0 <= t_x_{4}_{60} <= 1
+ 0 <= t_x_{4}_{75} <= 1
+ 0 <= t_x_{4}_{90} <= 0
+ 0 <= t_x_{4}_{105} <= 0
+ 0 <= t_x_{4}_{120} <= 0
+ 0 <= t_x_{5}_{0} <= 1
+ 0 <= t_x_{5}_{15} <= 1
+ 0 <= t_x_{5}_{30} <= 1
+ 0 <= t_x_{5}_{45} <= 1
+ 0 <= t_x_{5}_{60} <= 1
+ 0 <= t_x_{5}_{75} <= 1
+ 0 <= t_x_{5}_{90} <= 0
+ 0 <= t_x_{5}_{105} <= 0
+ 0 <= t_x_{5}_{120} <= 0
+ 0 <= t_x_{6}_{0} <= 1
+ 0 <= t_x_{6}_{15} <= 1
+ 0 <= t_x_{6}_{30} <= 1
+ 0 <= t_x_{6}_{45} <= 1
+ 0 <= t_x_{6}_{60} <= 1
+ 0 <= t_x_{6}_{75} <= 1
+ 0 <= t_x_{6}_{90} <= 0
+ 0 <= t_x_{6}_{105} <= 0
+ 0 <= t_x_{6}_{120} <= 0
+Binaries
+ t_x_{1}_{0} t_x_{1}_{15} t_x_{1}_{30} t_x_{1}_{45} t_x_{1}_{60} t_x_{1}_{75} t_x_{1}_{90} t_x_{1}_{105}
+ t_x_{1}_{120} t_x_{2}_{0} t_x_{2}_{15} t_x_{2}_{30} t_x_{2}_{45} t_x_{2}_{60} t_x_{2}_{75} t_x_{2}_{90}
+ t_x_{2}_{105} t_x_{2}_{120} t_x_{3}_{0} t_x_{3}_{15} t_x_{3}_{30} t_x_{3}_{45} t_x_{3}_{60} t_x_{3}_{75}
+ t_x_{3}_{90} t_x_{3}_{105} t_x_{3}_{120} t_x_{4}_{0} t_x_{4}_{15} t_x_{4}_{30} t_x_{4}_{45} t_x_{4}_{60}
+ t_x_{4}_{75} t_x_{4}_{90} t_x_{4}_{105} t_x_{4}_{120} t_x_{5}_{0} t_x_{5}_{15} t_x_{5}_{30} t_x_{5}_{45}
+ t_x_{5}_{60} t_x_{5}_{75} t_x_{5}_{90} t_x_{5}_{105} t_x_{5}_{120} t_x_{6}_{0} t_x_{6}_{15} t_x_{6}_{30}
+ t_x_{6}_{45} t_x_{6}_{60} t_x_{6}_{75} t_x_{6}_{90} t_x_{6}_{105} t_x_{6}_{120}
+End
diff --git a/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2 b/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2
index 7646cf7ffeb605a22cfef039e9b54308b7470493..e5990c187b37c0da0a444cab8cf1ee388826497c 100755
Binary files a/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2 and b/bin/LagrangianRelaxation.linux.x86_64.gnu.opt.spx2 differ
diff --git a/dual.txt b/dual.txt
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..f20efa7b22c8a15995020098e982408c121bcc2e 100644
--- a/dual.txt
+++ b/dual.txt
@@ -0,0 +1,21 @@
+dualbound = 1.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 21.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 41.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 61.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 78.000000, lowerbound=46.000000, norm of subgrad 5.099020 stepsize= 1.000000
+dualbound = 83.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 85.000000, lowerbound=75.000000, norm of subgrad 5.830952 stepsize= 1.000000
+dualbound = 93.000000, lowerbound=31.000000, norm of subgrad 5.099020 stepsize= 1.000000
+dualbound = 100.000000, lowerbound=46.000000, norm of subgrad 5.099020 stepsize= 1.000000
+dualbound = 105.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 103.000000, lowerbound=75.000000, norm of subgrad 5.830952 stepsize= 1.000000
+dualbound = 115.000000, lowerbound=31.000000, norm of subgrad 5.099020 stepsize= 1.000000
+dualbound = 119.000000, lowerbound=75.000000, norm of subgrad 5.830952 stepsize= 1.000000
+dualbound = 117.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 127.000000, lowerbound=75.000000, norm of subgrad 5.830952 stepsize= 1.000000
+dualbound = 129.000000, lowerbound=1.000000, norm of subgrad 6.164414 stepsize= 1.000000
+dualbound = 135.000000, lowerbound=75.000000, norm of subgrad 5.830952 stepsize= 1.000000
+dualbound = 139.000000, lowerbound=31.000000, norm of subgrad 5.099020 stepsize= 1.000000
+dualbound = 147.000000, lowerbound=31.000000, norm of subgrad 5.099020 stepsize= 1.000000
+dualbound = 152.000000, lowerbound=60.000000, norm of subgrad 5.099020 stepsize= 1.000000
+dualbound = 153.000000, lowerbound=61.000000, norm of subgrad 5.099020 stepsize= 1.000000
diff --git a/lowerbounds.txt b/lowerbounds.txt
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..2c00649f04f7aad1260860d43c81fd9ae4fc5ad5 100644
--- a/lowerbounds.txt
+++ b/lowerbounds.txt
@@ -0,0 +1,22 @@
+1.000000
+14.000000
+27.000000
+40.000000
+50.000000
+51.000000
+49.000000
+54.000000
+58.000000
+59.000000
+53.000000
+62.000000
+63.000000
+58.000000
+65.000000
+64.000000
+67.000000
+68.000000
+73.000000
+74.000000
+72.000000
+71.000000
diff --git a/obj/static/O.linux.x86_64.gnu.opt/probdata_lagr.o b/obj/static/O.linux.x86_64.gnu.opt/probdata_lagr.o
index 7e5b979768dd2bbe7213f53767eae1accfb489a8..443feb2f2b64a4969623f001989423ee55a8691d 100644
Binary files a/obj/static/O.linux.x86_64.gnu.opt/probdata_lagr.o and b/obj/static/O.linux.x86_64.gnu.opt/probdata_lagr.o differ
diff --git a/obj/static/O.linux.x86_64.gnu.opt/relax_lagr.o b/obj/static/O.linux.x86_64.gnu.opt/relax_lagr.o
index 5484d4c3e92bf6ec17dd9678cf50ceae9b9a9c2d..2640a527281af9008f8a7e4ba7f71b1af65ce37d 100644
Binary files a/obj/static/O.linux.x86_64.gnu.opt/relax_lagr.o and b/obj/static/O.linux.x86_64.gnu.opt/relax_lagr.o differ
diff --git a/probdata.txt b/probdata.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ee9f3ea3cd6b00bec3187074c25dedd799f73cec
--- /dev/null
+++ b/probdata.txt
@@ -0,0 +1,31 @@
+28 nslot conss
+all = 76
+ 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
+ 2 4 6 8 10 12 14 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 t_x_{1}_{0} t_x_{2}_{0}
+t_x_{1}_{15} t_x_{2}_{15}
+t_x_{1}_{30} t_x_{2}_{30}
+t_x_{1}_{45} t_x_{2}_{45}
+t_x_{1}_{60} t_x_{2}_{60}
+t_x_{1}_{75} t_x_{2}_{75}
+t_x_{1}_{90} t_x_{2}_{90}
+t_x_{1}_{105} t_x_{2}_{105}
+t_x_{2}_{0} t_x_{3}_{0} t_x_{4}_{0}
+t_x_{2}_{15} t_x_{3}_{15} t_x_{4}_{15}
+t_x_{2}_{30} t_x_{3}_{30} t_x_{4}_{30}
+t_x_{2}_{45} t_x_{3}_{45} t_x_{4}_{45}
+t_x_{2}_{60} t_x_{3}_{60} t_x_{4}_{60}
+t_x_{2}_{75} t_x_{3}_{75} t_x_{4}_{75}
+t_x_{2}_{90} t_x_{3}_{90} t_x_{4}_{90}
+t_x_{1}_{0} t_x_{3}_{0} t_x_{5}_{0}
+t_x_{1}_{15} t_x_{3}_{15} t_x_{5}_{15}
+t_x_{1}_{30} t_x_{3}_{30} t_x_{5}_{30}
+t_x_{1}_{45} t_x_{3}_{45} t_x_{5}_{45}
+t_x_{1}_{60} t_x_{3}_{60} t_x_{5}_{60}
+t_x_{1}_{75} t_x_{3}_{75} t_x_{5}_{75}
+t_x_{4}_{0} t_x_{5}_{0} t_x_{6}_{0}
+t_x_{4}_{15} t_x_{5}_{15} t_x_{6}_{15}
+t_x_{4}_{30} t_x_{5}_{30} t_x_{6}_{30}
+t_x_{4}_{45} t_x_{5}_{45} t_x_{6}_{45}
+t_x_{4}_{60} t_x_{5}_{60} t_x_{6}_{60}
+t_x_{4}_{75} t_x_{5}_{75} t_x_{6}_{75}
+t_x_{4}_{105} t_x_{5}_{105} t_x_{6}_{105}
diff --git a/sol.txt b/sol.txt
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..5c268155fb18f503994bda4d20ad462254b87d7d 100644
--- a/sol.txt
+++ b/sol.txt
@@ -0,0 +1,133 @@
+
+ F_6
+t_x_{6}_{0} 45 nvarincons = 1 var = t_x_{4}_{0} var = t_x_{5}_{0}
+(t_x_{6}_{0},45,1.000000)
+t_x_{6}_{15} 46 (t_x_{6}_{15},46,0.000000)
+t_x_{6}_{30} 47 (t_x_{6}_{30},47,0.000000)
+t_x_{6}_{45} 48 (t_x_{6}_{45},48,0.000000)
+t_x_{6}_{60} 49 (t_x_{6}_{60},49,0.000000)
+t_x_{6}_{75} 50 (t_x_{6}_{75},50,0.000000)
+t_x_{6}_{90} 51 (t_x_{6}_{90},51,0.000000)
+t_x_{6}_{105} 52 (t_x_{6}_{105},52,0.000000)
+t_x_{6}_{120} 53 (t_x_{6}_{120},53,0.000000)
+
+
+ F_4
+t_x_{4}_{0} 27 (t_x_{4}_{0},27,0.000000)
+t_x_{4}_{15} 28 nvarincons = 2 var = t_x_{2}_{15} var = t_x_{3}_{15} var = t_x_{5}_{15} var = t_x_{6}_{15}
+(t_x_{4}_{15},28,1.000000)
+t_x_{4}_{30} 29 (t_x_{4}_{30},29,0.000000)
+t_x_{4}_{45} 30 (t_x_{4}_{45},30,0.000000)
+t_x_{4}_{60} 31 (t_x_{4}_{60},31,0.000000)
+t_x_{4}_{75} 32 (t_x_{4}_{75},32,0.000000)
+t_x_{4}_{90} 33 (t_x_{4}_{90},33,0.000000)
+t_x_{4}_{105} 34 (t_x_{4}_{105},34,0.000000)
+t_x_{4}_{120} 35 (t_x_{4}_{120},35,0.000000)
+
+
+ F_5
+t_x_{5}_{0} 36 (t_x_{5}_{0},36,0.000000)
+t_x_{5}_{15} 37 (t_x_{5}_{15},37,0.000000)
+t_x_{5}_{30} 38 nvarincons = 2 var = t_x_{1}_{30} var = t_x_{3}_{30} var = t_x_{4}_{30} var = t_x_{6}_{30}
+(t_x_{5}_{30},38,1.000000)
+t_x_{5}_{45} 39 (t_x_{5}_{45},39,0.000000)
+t_x_{5}_{60} 40 (t_x_{5}_{60},40,0.000000)
+t_x_{5}_{75} 41 (t_x_{5}_{75},41,0.000000)
+t_x_{5}_{90} 42 (t_x_{5}_{90},42,0.000000)
+t_x_{5}_{105} 43 (t_x_{5}_{105},43,0.000000)
+t_x_{5}_{120} 44 (t_x_{5}_{120},44,0.000000)
+
+
+ F_3
+t_x_{3}_{0} 18 nvarincons = 2 var = t_x_{2}_{0} var = t_x_{4}_{0} var = t_x_{1}_{0} var = t_x_{5}_{0}
+(t_x_{3}_{0},18,1.000000)
+t_x_{3}_{15} 19 (t_x_{3}_{15},19,0.000000)
+t_x_{3}_{30} 20 (t_x_{3}_{30},20,0.000000)
+t_x_{3}_{45} 21 (t_x_{3}_{45},21,0.000000)
+t_x_{3}_{60} 22 (t_x_{3}_{60},22,0.000000)
+t_x_{3}_{75} 23 (t_x_{3}_{75},23,0.000000)
+t_x_{3}_{90} 24 (t_x_{3}_{90},24,0.000000)
+t_x_{3}_{105} 25 (t_x_{3}_{105},25,0.000000)
+t_x_{3}_{120} 26 (t_x_{3}_{120},26,0.000000)
+
+
+ F_1
+t_x_{1}_{0} 0 (t_x_{1}_{0},0,0.000000)
+t_x_{1}_{15} 1 nvarincons = 2 var = t_x_{2}_{15} var = t_x_{3}_{15} var = t_x_{5}_{15}
+(t_x_{1}_{15},1,1.000000)
+t_x_{1}_{30} 2 (t_x_{1}_{30},2,0.000000)
+t_x_{1}_{45} 3 (t_x_{1}_{45},3,0.000000)
+t_x_{1}_{60} 4 (t_x_{1}_{60},4,0.000000)
+t_x_{1}_{75} 5 (t_x_{1}_{75},5,0.000000)
+t_x_{1}_{90} 6 (t_x_{1}_{90},6,0.000000)
+t_x_{1}_{105} 7 (t_x_{1}_{105},7,0.000000)
+t_x_{1}_{120} 8 (t_x_{1}_{120},8,0.000000)
+
+
+ F_2
+t_x_{2}_{0} 9 (t_x_{2}_{0},9,0.000000)
+t_x_{2}_{15} 10 (t_x_{2}_{15},10,0.000000)
+t_x_{2}_{30} 11 nvarincons = 2 var = t_x_{1}_{30} var = t_x_{3}_{30} var = t_x_{4}_{30}
+(t_x_{2}_{30},11,1.000000)
+t_x_{2}_{45} 12 (t_x_{2}_{45},12,0.000000)
+t_x_{2}_{60} 13 (t_x_{2}_{60},13,0.000000)
+t_x_{2}_{75} 14 (t_x_{2}_{75},14,0.000000)
+t_x_{2}_{90} 15 (t_x_{2}_{90},15,0.000000)
+t_x_{2}_{105} 16 (t_x_{2}_{105},16,0.000000)
+t_x_{2}_{120} 17 (t_x_{2}_{120},17,0.000000)
+
+ (t_x_{1}_{0} 0.000000 weight 1.000000)
+ (t_x_{1}_{15} 1.000000 weight 15.000000)
+ (t_x_{1}_{30} 0.000000 weight 30.000000)
+ (t_x_{1}_{45} 0.000000 weight 45.000000)
+ (t_x_{1}_{60} 0.000000 weight 60.000000)
+ (t_x_{1}_{75} 0.000000 weight 75.000000)
+ (t_x_{1}_{90} 0.000000 weight 90.000000)
+ (t_x_{1}_{105} 0.000000 weight 105.000000)
+ (t_x_{1}_{120} 0.000000 weight 120.000000)
+ (t_x_{2}_{0} 0.000000 weight 0.000000)
+ (t_x_{2}_{15} 0.000000 weight 15.000000)
+ (t_x_{2}_{30} 1.000000 weight 30.000000)
+ (t_x_{2}_{45} 0.000000 weight 45.000000)
+ (t_x_{2}_{60} 0.000000 weight 60.000000)
+ (t_x_{2}_{75} 0.000000 weight 75.000000)
+ (t_x_{2}_{90} 0.000000 weight 90.000000)
+ (t_x_{2}_{105} 0.000000 weight 105.000000)
+ (t_x_{2}_{120} 0.000000 weight 120.000000)
+ (t_x_{3}_{0} 1.000000 weight 0.000000)
+ (t_x_{3}_{15} 0.000000 weight 15.000000)
+ (t_x_{3}_{30} 0.000000 weight 30.000000)
+ (t_x_{3}_{45} 0.000000 weight 45.000000)
+ (t_x_{3}_{60} 0.000000 weight 60.000000)
+ (t_x_{3}_{75} 0.000000 weight 75.000000)
+ (t_x_{3}_{90} 0.000000 weight 90.000000)
+ (t_x_{3}_{105} 0.000000 weight 105.000000)
+ (t_x_{3}_{120} 0.000000 weight 120.000000)
+ (t_x_{4}_{0} 0.000000 weight 0.000000)
+ (t_x_{4}_{15} 1.000000 weight 15.000000)
+ (t_x_{4}_{30} 0.000000 weight 30.000000)
+ (t_x_{4}_{45} 0.000000 weight 45.000000)
+ (t_x_{4}_{60} 0.000000 weight 60.000000)
+ (t_x_{4}_{75} 0.000000 weight 75.000000)
+ (t_x_{4}_{90} 0.000000 weight 90.000000)
+ (t_x_{4}_{105} 0.000000 weight 105.000000)
+ (t_x_{4}_{120} 0.000000 weight 120.000000)
+ (t_x_{5}_{0} 0.000000 weight 0.000000)
+ (t_x_{5}_{15} 0.000000 weight 15.000000)
+ (t_x_{5}_{30} 1.000000 weight 30.000000)
+ (t_x_{5}_{45} 0.000000 weight 45.000000)
+ (t_x_{5}_{60} 0.000000 weight 60.000000)
+ (t_x_{5}_{75} 0.000000 weight 75.000000)
+ (t_x_{5}_{90} 0.000000 weight 90.000000)
+ (t_x_{5}_{105} 0.000000 weight 105.000000)
+ (t_x_{5}_{120} 0.000000 weight 120.000000)
+ (t_x_{6}_{0} 1.000000 weight 0.000000)
+ (t_x_{6}_{15} 0.000000 weight 15.000000)
+ (t_x_{6}_{30} 0.000000 weight 30.000000)
+ (t_x_{6}_{45} 0.000000 weight 45.000000)
+ (t_x_{6}_{60} 0.000000 weight 60.000000)
+ (t_x_{6}_{75} 0.000000 weight 75.000000)
+ (t_x_{6}_{90} 0.000000 weight 90.000000)
+ (t_x_{6}_{105} 0.000000 weight 105.000000)
+ (t_x_{6}_{120} 0.000000 weight 120.000000)
+
\ No newline at end of file
diff --git a/src/probdata_lagr.cpp b/src/probdata_lagr.cpp
index 20f6666df11db5ec0bbc27c1ba3f61d52228ba69..0363583eb0150dffa42256b21cdb985c9b09c54b 100644
--- a/src/probdata_lagr.cpp
+++ b/src/probdata_lagr.cpp
@@ -176,6 +176,8 @@ SCIP_RETCODE SCIPcreateprobdata
int** badconss
)
{
+ FILE* prob;
+ prob = fopen("probdata.txt","wr");
int nconss = SCIPgetNConss(relaxscip);
int nvars = SCIPgetNVars(relaxscip);
int nSlotConss = 0;
@@ -189,7 +191,7 @@ SCIP_RETCODE SCIPcreateprobdata
++nSlotConss;
}
}
- printf("%d nslot conss",nSlotConss);
+ fprintf(prob,"%d nslot conss \n",nSlotConss);
int allnconsvars=0;
int nconsvars=0;
@@ -239,7 +241,11 @@ SCIP_RETCODE SCIPcreateprobdata
{
(*varbuffers)[v] =vars[v];
}
- printf("all = %d\n",allnconsvars);
+ // for (int v = 0; v < nvars; v++)
+ // {
+ // fprintf(prob,"(%s %d)\t", SCIPvarGetName(vars[v]), SCIPvarGetIndex(vars[v]));
+ // }
+ fprintf(prob,"all = %d\n",allnconsvars);
counter=0;
for (int r = 0; r < nSlotConss; ++r)
@@ -254,7 +260,7 @@ SCIP_RETCODE SCIPcreateprobdata
if (!success){
abort(); }
listnconsvars[r] = nconsvars;
- printf(" %d ",listnconsvars[r]);
+ fprintf(prob," %d ",listnconsvars[r]);
for (int j = 0; j < nconsvars; ++j) /* (8) */
{
SCIP_VAR* varx = (*varbuffers)[j];
@@ -264,23 +270,29 @@ SCIP_RETCODE SCIPcreateprobdata
counter++;
}
}
- printf("\n");
+
int* increasingorder; //example {2,4,6,9,12,...}
SCIP_CALL(SCIPallocBufferArray(relaxscip,&increasingorder,nSlotConss));
increasingorder[0] = listnconsvars[0]; //listnconsvars[0];
for(int r=1; r<nSlotConss;r++)
{
increasingorder[r]=listnconsvars[r]+increasingorder[r-1];
- // printf(" %d ",increasingorder[r]);
+
+ }
+ fprintf(prob,"\n");
+ //printing to prob.txt
+ for(int r=0; r<nSlotConss;r++)
+ {
+ fprintf(prob," %d ",increasingorder[r]);
}
for(int r=0; r<nSlotConss;r++)
{
for (int p = increasingorder[r]-listnconsvars[r]; p < increasingorder[r]; p++)
{
- printf("%d ",listconsvarids[p]);
+ fprintf(prob,"%s ",SCIPvarGetName(vars[listconsvarids[p]]));
}
- printf("\n");
+ fprintf(prob,"\n");
}
// for(int s=0;s<allnconsvars;s++)
@@ -360,7 +372,7 @@ SCIP_RETCODE SCIPcreateprobdata
// // // printf("%d\n->",counter);
// }
-
+ fclose(prob);
SCIP_CALL(SCIPallocMemory(relaxscip,probdata));
(*probdata)->nSlotConss = nSlotConss;
diff --git a/src/relax_lagr.cpp b/src/relax_lagr.cpp
index 3cccb7ad99975aa52ebe5a937f82e6640da7ef2f..b556e0aca96e4719111c533d1bca76fa45b87762 100644
--- a/src/relax_lagr.cpp
+++ b/src/relax_lagr.cpp
@@ -42,8 +42,8 @@
#define RELAX_NAME "lagr"
-#define RELAX_DESC "relaxator template"
-#define RELAX_PRIORITY 0
+#define RELAX_DESC "relaxator"
+#define RELAX_PRIORITY 100000
#define RELAX_FREQ 0
@@ -115,320 +115,320 @@ static
SCIP_DECL_RELAXINIT(relaxInitlagr)
{ /*lint --e{715}*/
- SCIP* relaxscip;
- SCIP_HASHMAP* varmap;
- SCIP_HASHMAP* consmap;
- SCIP_CONS** conss;
- SCIP_PROBDATA* probdata;
- SCIP_VARDATA* vardata;
-
- SCIP_Real relaxval;
- SCIP_Bool valid;
- int nconss;
- int i;
- int counter;
- int id;
-
-
- // *lowerbound = -SCIPinfinity(scip);
- // *result = SCIP_DIDNOTRUN;
-
- /* we can only run if none of the present constraints expect their variables to be binary or integer during transformation */
- conss = SCIPgetConss(scip);
- nconss = SCIPgetNConss(scip);
-
- /* create the variable mapping hash map */
- SCIP_CALL( SCIPcreate(&relaxscip) );
- SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(relaxscip), SCIPgetNVars(scip)) );
- valid = FALSE;
- SCIP_CALL( SCIPcopy(scip, relaxscip, varmap, consmap, "relaxscip", FALSE, FALSE, FALSE, FALSE, &valid) );
+ // SCIP* relaxscip;
+ // SCIP_HASHMAP* varmap;
+ // SCIP_HASHMAP* consmap;
+ // SCIP_CONS** conss;
+ // SCIP_PROBDATA* probdata;
+ // SCIP_VARDATA* vardata;
+
+ // SCIP_Real relaxval;
+ // SCIP_Bool valid;
+ // int nconss;
+ // int i;
+ // int counter;
+ // int id;
+
+
+ // // *lowerbound = -SCIPinfinity(scip);
+ // // *result = SCIP_DIDNOTRUN;
+
+ // /* we can only run if none of the present constraints expect their variables to be binary or integer during transformation */
+ // conss = SCIPgetConss(scip);
+ // nconss = SCIPgetNConss(scip);
+
+ // /* create the variable mapping hash map */
+ // SCIP_CALL( SCIPcreate(&relaxscip) );
+ // SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(relaxscip), SCIPgetNVars(scip)) );
+ // valid = FALSE;
+ // SCIP_CALL( SCIPcopy(scip, relaxscip, varmap, consmap, "relaxscip", FALSE, FALSE, FALSE, FALSE, &valid) );
- /**************************************************************************************************************/
- /*First, */
- //*the probdata: where we get to identify the bad constraint we want to formulate(in our case, the slot conss) */
- /***************************************************************************************************************/
- int nvars = SCIPgetNVars(relaxscip);
- SCIP_VAR** vars = SCIPgetVars(relaxscip);
- SCIP_VAR** varbuffers;
- int* badconss;
+ // /**************************************************************************************************************/
+ // /*First, */
+ // //*the probdata: where we get to identify the bad constraint we want to formulate(in our case, the slot conss) */
+ // /***************************************************************************************************************/
+ // int nvars = SCIPgetNVars(relaxscip);
+ // SCIP_VAR** vars = SCIPgetVars(relaxscip);
+ // SCIP_VAR** varbuffers;
+ // int* badconss;
- SCIPcreateprobdata(relaxscip,&probdata,SCIPgetConss(relaxscip),vars,&varbuffers,&badconss); /*will be used to identify the # of slot(bad) constraints*/
- int nSlotConss = SCIPgetNSlotConss(probdata); //number of bad(slot) constraint
- int allnconsvars = SCIPgetallnconsvars(probdata); //sum of all nconsvars, used for creating later on an array to collect the list of varids in each row
- int* listnconsvars = SCIPlistnconsvars(probdata);
- int* listconsvarids = SCIPlistconsvarids(probdata);
- int* increasingorder = SCIPlistincreasing(probdata);
+ // SCIPcreateprobdata(relaxscip,&probdata,SCIPgetConss(relaxscip),vars,&varbuffers,&badconss); /*will be used to identify the # of slot(bad) constraints*/
+ // int nSlotConss = SCIPgetNSlotConss(probdata); //number of bad(slot) constraint
+ // int allnconsvars = SCIPgetallnconsvars(probdata); //sum of all nconsvars, used for creating later on an array to collect the list of varids in each row
+ // int* listnconsvars = SCIPlistnconsvars(probdata);
+ // int* listconsvarids = SCIPlistconsvarids(probdata);
+ // int* increasingorder = SCIPlistincreasing(probdata);
- /* we then create the vardata function for each variable, to see at which constraint the variable is found*/
- FILE* TimeCollector;
- TimeCollector = fopen("time.txt","w");
- SCIP_CLOCK* varslottime; //to help us record the time
- SCIP_CALL( SCIPcreateClock(relaxscip, &varslottime) ); //* start time counting*
- SCIP_CALL(SCIPstartClock(relaxscip,varslottime));
+ // /* we then create the vardata function for each variable, to see at which constraint the variable is found*/
+ // FILE* TimeCollector;
+ // TimeCollector = fopen("time.txt","w");
+ // SCIP_CLOCK* varslottime; //to help us record the time
+ // SCIP_CALL( SCIPcreateClock(relaxscip, &varslottime) ); //* start time counting*
+ // SCIP_CALL(SCIPstartClock(relaxscip,varslottime));
- SCIP_CLOCK* totaliteration; //to help us record the time
- SCIP_CALL( SCIPcreateClock(relaxscip, &totaliteration) ); //* start time counting*
+ // SCIP_CLOCK* totaliteration; //to help us record the time
+ // SCIP_CALL( SCIPcreateClock(relaxscip, &totaliteration) ); //* start time counting*
- int* consids;
+ // int* consids;
- SCIP_Real* weights;
- SCIP_CALL(SCIPallocBufferArray(relaxscip,&weights,nvars));
+ // SCIP_Real* weights;
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip,&weights,nvars));
- SCIP_CALL(SCIPallocBufferArray(relaxscip,&consids,nSlotConss));
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip,&consids,nSlotConss));
- SCIP_Real maxobj=0;
- for (int v = 0; v < nvars; v++)
- {
- SCIP_VAR* var = vars[v];
- weights[v]=SCIPvarGetObj(var);
- if(maxobj<weights[v]){maxobj=weights[v];}
- }
+ // SCIP_Real maxobj=0;
+ // for (int v = 0; v < nvars; v++)
+ // {
+ // SCIP_VAR* var = vars[v];
+ // weights[v]=SCIPvarGetObj(var);
+ // if(maxobj<weights[v]){maxobj=weights[v];}
+ // }
- for (int v = 0; v < nvars; v++)
- {
- int* varids;
- int NVarInBadConss=0;
- int nconsvars = 0;
- SCIP_VAR* var = vars[v];
+ // for (int v = 0; v < nvars; v++)
+ // {
+ // int* varids;
+ // int NVarInBadConss=0;
+ // int nconsvars = 0;
+ // SCIP_VAR* var = vars[v];
- int varindex = SCIPvarGetIndex(var); /* (2) */
- assert(varindex!= NULL);
+ // int varindex = SCIPvarGetIndex(var); /* (2) */
+ // assert(varindex!= NULL);
- for (int r = 0; r < nSlotConss; ++r)
- {
- id = badconss[r];
- SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
- // printf("%s \t",SCIPconsGetName(cons));
- SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
- SCIP_CALL(SCIPgetConsVars(relaxscip, cons, varbuffers, nconsvars, &valid));
- if (!valid){abort(); }
+ // for (int r = 0; r < nSlotConss; ++r)
+ // {
+ // id = badconss[r];
+ // SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
+ // // printf("%s \t",SCIPconsGetName(cons));
+ // SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
+ // SCIP_CALL(SCIPgetConsVars(relaxscip, cons, varbuffers, nconsvars, &valid));
+ // if (!valid){abort(); }
- for (int j = 0; j < nconsvars; ++j) /* (8) */
- {
- SCIP_VAR* varx = varbuffers[j];
- int varbufindex = SCIPvarGetIndex(varx);
- assert(varbufindex != NULL);
- // printf("%s\t \t%d",SCIPvarGetName(varx),varbufindex);
+ // for (int j = 0; j < nconsvars; ++j) /* (8) */
+ // {
+ // SCIP_VAR* varx = varbuffers[j];
+ // int varbufindex = SCIPvarGetIndex(varx);
+ // assert(varbufindex != NULL);
+ // // printf("%s\t \t%d",SCIPvarGetName(varx),varbufindex);
- /** if var[i] is in cons[c], write conspointer in VarConss and increase nVarConsscounter */
- if (varindex == varbufindex) /* (9) */
- {
+ // /** if var[i] is in cons[c], write conspointer in VarConss and increase nVarConsscounter */
+ // if (varindex == varbufindex) /* (9) */
+ // {
- // VarSlotConss[NVarInBadConss] = cons;
- consids[NVarInBadConss]=id;
- NVarInBadConss++;
- // printf(" %s \t,",SCIPconsGetName(cons));
- }
- }
- }
+ // // VarSlotConss[NVarInBadConss] = cons;
+ // consids[NVarInBadConss]=id;
+ // NVarInBadConss++;
+ // // printf(" %s \t,",SCIPconsGetName(cons));
+ // }
+ // }
+ // }
- SCIP_CALL(SCIPallocBufferArray(relaxscip, &varids, NVarInBadConss));
- for(int t=0;t<NVarInBadConss;t++)
- {
- varids[t]=consids[t];
- // printf("%d \t",varids[t]);
- }
- // printf("\n");
- // // vardata=SCIPvarGetData(var);
- SCIP_CALL(SCIPallocBlockMemory(scip , &vardata));
- SCIP_CALL(SCIPduplicateBlockMemoryArray(scip, &(vardata->varids), varids, NVarInBadConss));
- vardata->NVarInBadConss = NVarInBadConss; /**copy nVarConss to VarData */
- vardata->varids = varids;
- // /**set the variable data to the variable*/
- SCIPvarSetData(var,vardata);
- }
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip, &varids, NVarInBadConss));
+ // for(int t=0;t<NVarInBadConss;t++)
+ // {
+ // varids[t]=consids[t];
+ // // printf("%d \t",varids[t]);
+ // }
+ // // printf("\n");
+ // // // vardata=SCIPvarGetData(var);
+ // SCIP_CALL(SCIPallocBlockMemory(scip , &vardata));
+ // SCIP_CALL(SCIPduplicateBlockMemoryArray(scip, &(vardata->varids), varids, NVarInBadConss));
+ // vardata->NVarInBadConss = NVarInBadConss; /**copy nVarConss to VarData */
+ // vardata->varids = varids;
+ // // /**set the variable data to the variable*/
+ // SCIPvarSetData(var,vardata);
+ // }
- SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
+ // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
- FILE* AfterPreProcessing;
- AfterPreProcessing = fopen("AfterPreProcessing.txt","w+");
+ // FILE* AfterPreProcessing;
+ // AfterPreProcessing = fopen("AfterPreProcessing.txt","w+");
- // SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
+ // // SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
- SCIPinfoMessage(relaxscip, TimeCollector, "\n row and column identified in (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
- for(int r=0;r<nSlotConss;r++)
- {
- id = badconss[r];
- SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
- SCIP_CALL(SCIPdelCons(relaxscip,cons));
- }
+ // SCIPinfoMessage(relaxscip, TimeCollector, "\n row and column identified in (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
+ // for(int r=0;r<nSlotConss;r++)
+ // {
+ // id = badconss[r];
+ // SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
+ // SCIP_CALL(SCIPdelCons(relaxscip,cons));
+ // }
- /******************************************************************************************************************/
- /*Next, we will do the initial iteration of finding the dual mulpliers of each slot conss, and their sum(dualsum) */
- /* In the end, we will subtract this sum from the objective of the function. */
- /* It's initial, because while we would search for more dual multipliers to solve the Lagrangian relaxation */
- /******************************************************************************************************************/
- SCIP_Real* dualmultipliers;
- SCIP_CALL(SCIPallocBufferArray(relaxscip,&dualmultipliers,nSlotConss));
+ // /******************************************************************************************************************/
+ // /*Next, we will do the initial iteration of finding the dual mulpliers of each slot conss, and their sum(dualsum) */
+ // /* In the end, we will subtract this sum from the objective of the function. */
+ // /* It's initial, because while we would search for more dual multipliers to solve the Lagrangian relaxation */
+ // /******************************************************************************************************************/
+ // SCIP_Real* dualmultipliers;
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip,&dualmultipliers,nSlotConss));
- SCIP_Real* subgradients;
- SCIP_CALL(SCIPallocBufferArray(relaxscip,&subgradients,nSlotConss));
- //initialize subgradients;
- SCIP_Real stepsize = 15;
- SCIP_Real sumofduals=0;
- for ( int r = 0; r < nSlotConss; ++r)
- {
- dualmultipliers[r] = 0;
- sumofduals+=dualmultipliers[r]; //adds the negative of the minimum in each iteration
- }
+ // SCIP_Real* subgradients;
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip,&subgradients,nSlotConss));
+ // //initialize subgradients;
+ // SCIP_Real stepsize = 15;
+ // SCIP_Real sumofduals=0;
+ // for ( int r = 0; r < nSlotConss; ++r)
+ // {
+ // dualmultipliers[r] = 0;
+ // sumofduals+=dualmultipliers[r]; //adds the negative of the minimum in each iteration
+ // }
- // /*******************************************************************************************************/
- // /* The reformulation of the problem can be written as follows */
- // //*>>>>>>>>>>>>>>>>>> min sum { (w[i]+sum{dual[j]})}x[i]-sum{dual[r]} <<<<<<<<<<<< */
- // /*where i is nvars, j is NVarInBadConss, and r is nSlotConss for our case *******************************/
- // /****************************************************************************************************************/
- // /* The following function will add the following to the obj(weight) of the variable, */
- // //* the obj(weight) of var + the sum of the dualmultipliers of bad constraints which contains this variable */
- // /****************************************************************************************************************/
+ // // /*******************************************************************************************************/
+ // // /* The reformulation of the problem can be written as follows */
+ // // //*>>>>>>>>>>>>>>>>>> min sum { (w[i]+sum{dual[j]})}x[i]-sum{dual[r]} <<<<<<<<<<<< */
+ // // /*where i is nvars, j is NVarInBadConss, and r is nSlotConss for our case *******************************/
+ // // /****************************************************************************************************************/
+ // // /* The following function will add the following to the obj(weight) of the variable, */
+ // // //* the obj(weight) of var + the sum of the dualmultipliers of bad constraints which contains this variable */
+ // // /****************************************************************************************************************/
- FILE* solutions;
- solutions = fopen("sol.txt","wr");
- FILE* dual;
- dual= fopen("dual.txt","wr");
- FILE* variableinfo;
- variableinfo = fopen("var.txt","wr");
- FILE* subgrad;
- subgrad = fopen("subgrads.txt","wr");
- FILE* varobjects;
- varobjects=fopen("varobjs.txt","wr");
- FILE* lower;
- lower=fopen("lowerbounds.txt","wr");
- FILE* iter;
- iter=fopen("iter.txt","wr");
-
+ // FILE* solutions;
+ // solutions = fopen("sol.txt","wr");
+ // FILE* dual;
+ // dual= fopen("dual.txt","wr");
+ // FILE* variableinfo;
+ // variableinfo = fopen("var.txt","wr");
+ // FILE* subgrad;
+ // subgrad = fopen("subgrads.txt","wr");
+ // FILE* varobjects;
+ // varobjects=fopen("varobjs.txt","wr");
+ // FILE* lower;
+ // lower=fopen("lowerbounds.txt","wr");
+ // FILE* iter;
+ // iter=fopen("iter.txt","wr");
- //fprintf(lower, "hi");
- SCIP_Real* solvals;
- SCIP_CALL(SCIPallocBufferArray(relaxscip,&solvals,nvars+2));
- solvals[nvars+1]=0; //for last solutions
- solvals[nvars]=0; //for best solution
- int maxiter=1500;
+ // //fprintf(lower, "hi");
+ // SCIP_Real* solvals;
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip,&solvals,nvars+2));
+ // solvals[nvars+1]=0; //for last solutions
+ // solvals[nvars]=0; //for best solution
- int oscilatecounter=0;
- int improvementcounter = 0;
- SCIP_Real oscilator1=0;
- SCIP_Real oscilator2=0;
- SCIP_Real forcompare = -1000000000000000000;
- SCIP_CALL(SCIPstartClock(relaxscip,totaliteration));
+ // int maxiter=1500;
- int* feasol;
- SCIP_CALL(SCIPallocBufferArray(relaxscip,&feasol,nvars)); //will containt a feasible solution for our problem.
- for(int v=0;v<nvars;v++)
- {
- feasol[v]=-1; //we assign initial values equal to -1, signifying that the variable's value hasn't been decided yet.
- }
+ // int oscilatecounter=0;
+ // int improvementcounter = 0;
+ // SCIP_Real oscilator1=0;
+ // SCIP_Real oscilator2=0;
+ // SCIP_Real forcompare = -1000000000000000000;
+ // SCIP_CALL(SCIPstartClock(relaxscip,totaliteration));
+ // SCIP_Real* feasol;
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip,&feasol,nvars)); //will containt a feasible solution for our problem.
// for(int v=0;v<nvars;v++)
// {
- // printf(" %d ",feasol[v]);
-
+ // feasol[v]=-1; //we assign initial values equal to -1, signifying that the variable's value hasn't been decided yet.
// }
+ // // for(int v=0;v<nvars;v++)
+ // // {
+ // // printf(" %d ",feasol[v]);
+
+ // // }
+
- int* nvarsingoodconss;
- SCIP_CALL(SCIPallocBufferArray(relaxscip,&nvarsingoodconss,SCIPgetNConss(relaxscip))); //will contain {9,9,9,9,9,9} for the 6f4s problem.
+ // int* nvarsingoodconss;
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip,&nvarsingoodconss,SCIPgetNConss(relaxscip))); //will contain {9,9,9,9,9,9} for the 6f4s problem.
- int maxnvarsingoodconss = 0; //max number of variables found in a start constraint
- int nconsvars = 0; //number of vars in a startconss.
+ // int maxnvarsingoodconss = 0; //max number of variables found in a start constraint
+ // int nconsvars = 0; //number of vars in a startconss.
- for(int r = 0; r<SCIPgetNConss(relaxscip);r++)
- {
- SCIP_CONS* cons = SCIPgetConss(relaxscip)[r];
- SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
- if(nconsvars>maxnvarsingoodconss){maxnvarsingoodconss=nconsvars;}
- nvarsingoodconss[r]=nconsvars;
- }
+ // for(int r = 0; r<SCIPgetNConss(relaxscip);r++)
+ // {
+ // SCIP_CONS* cons = SCIPgetConss(relaxscip)[r];
+ // SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
+ // if(nconsvars>maxnvarsingoodconss){maxnvarsingoodconss=nconsvars;}
+ // nvarsingoodconss[r]=nconsvars;
+ // }
- printf("%d \n",maxnvarsingoodconss);
+ // // printf("%d \n",maxnvarsingoodconss);
- SCIP_VAR** VARSinsidegoodconss; //will contain the variable in a start constraint
- SCIP_CALL(SCIPallocBufferArray(relaxscip, &VARSinsidegoodconss, maxnvarsingoodconss)); //the size is the max num a start constraint can hold. We do this not to allocate memory over and over again.
+ // SCIP_VAR** VARSinsidegoodconss; //will contain the variable in a start constraint
+ // SCIP_CALL(SCIPallocBufferArray(relaxscip, &VARSinsidegoodconss, maxnvarsingoodconss)); //the size is the max num a start constraint can hold. We do this not to allocate memory over and over again.
- for(int r = 0; r<SCIPgetNConss(relaxscip);r++)
- {
- SCIP_CONS* cons = SCIPgetConss(relaxscip)[r];
- SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
- SCIP_CALL(SCIPgetConsVars(relaxscip, cons, VARSinsidegoodconss, nconsvars, &valid));
- if (!valid){abort(); }
- printf("\n %s\n",SCIPconsGetName(cons));
- for (int j = 0; j < nconsvars; ++j) /* (8) */
- {
- SCIP_VAR* varx = (VARSinsidegoodconss)[j];
- printf("%s\t",SCIPvarGetName(varx));
- int varbufindex = SCIPvarGetIndex(varx); //get the index, which will be used in assigning values to the feassol.
- assert(varbufindex != NULL);
- // printf("%d\t",varbufindex);
+ // for(int r = 0; r<SCIPgetNConss(relaxscip);r++)
+ // {
+ // SCIP_CONS* cons = SCIPgetConss(relaxscip)[r];
+ // SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
+ // SCIP_CALL(SCIPgetConsVars(relaxscip, cons, VARSinsidegoodconss, nconsvars, &valid));
+ // if (!valid){abort(); }
+ // // printf("\n %s\n",SCIPconsGetName(cons));
+ // for (int j = 0; j < nconsvars; ++j) /* (8) */
+ // {
+ // SCIP_VAR* varx = (VARSinsidegoodconss)[j];
+ // // printf("%s\t",SCIPvarGetName(varx));
+ // int varbufindex = SCIPvarGetIndex(varx); //get the index, which will be used in assigning values to the feassol.
+ // assert(varbufindex != NULL);
+ // // printf("%d\t",varbufindex);
- if (feasol[varbufindex]==-1)
- {
- feasol[varbufindex]=1;
- for(int s=j+1; s<nconsvars;++s)
- {
- SCIP_VAR* varnext = (VARSinsidegoodconss)[s];
- int varnextindex = SCIPvarGetIndex(varnext);
- feasol[varnextindex]=0;
- }
+ // if (feasol[varbufindex]==-1)
+ // {
+ // feasol[varbufindex]=1;
+ // for(int s=j+1; s<nconsvars;++s)
+ // {
+ // SCIP_VAR* varnext = (VARSinsidegoodconss)[s];
+ // int varnextindex = SCIPvarGetIndex(varnext);
+ // feasol[varnextindex]=0;
+ // }
- vardata=SCIPvarGetData(varx);
- int* varids = SCIPvardataGetvarids(vardata);
- assert(varids=!NULL);
- int NVarInBadConss = SCIPvardataGetNVarInBadConss(vardata);
- printf("nvarincons = %d\t",NVarInBadConss);
+ // vardata=SCIPvarGetData(varx);
+ // int* varids = SCIPvardataGetvarids(vardata);
+ // assert(varids=!NULL);
+ // int NVarInBadConss = SCIPvardataGetNVarInBadConss(vardata);
+ // // printf("nvarincons = %d\t",NVarInBadConss);
- for(int t=0;t<NVarInBadConss;t++)
- {
- printf("%d \t",varids[t]);
- // varids[t] gives the constraint address. There we still would like to find out which variables are found.
- for(int p=increasingorder[varids[t]]-listnconsvars[varids[t]]; p<increasingorder[varids[t]]; ++p)
- {
-
- if(SCIPvarGetIndex(vars[listconsvarids[p]])!=varbufindex)
- {
- printf("var = %s\t",SCIPvarGetName(vars[listconsvarids[p]]));
- if(feasol[listconsvarids[p]]==-1)
- {
- feasol[listconsvarids[p]]=0;
- }
- }
- }
- }
- // printf("\n");
- }
+ // for(int t=0;t<NVarInBadConss;t++)
+ // {
+ // // printf("%d \t",varids[t]);
+ // // varids[t] gives the constraint address. There we still would like to find out which variables are found.
+ // for(int p=increasingorder[varids[t]]-listnconsvars[varids[t]]; p<increasingorder[varids[t]]; ++p)
+ // {
+
+ // if(SCIPvarGetIndex(vars[listconsvarids[p]])!=varbufindex)
+ // {
+ // // printf("var = %s\t",SCIPvarGetName(vars[listconsvarids[p]]));
+ // if(feasol[listconsvarids[p]]==-1)
+ // {
+ // feasol[listconsvarids[p]]=0;
+ // }
+ // }
+ // }
+ // }
+ // // printf("\n");
+ // }
- printf("(%s,%d,%d)\n",SCIPvarGetName(varx), varbufindex,feasol[varbufindex]);
+ // // printf("(%s,%d,%d)\n",SCIPvarGetName(varx), varbufindex,feasol[varbufindex]);
- }
- // printf("\n");
- }
+ // }
+ // // printf("\n");
+ // }
- SCIP_Real upperbound=0;
- for(int v=0;v<nvars;v++)
- {
- printf(" (%s %d weight %f) \n ", SCIPvarGetName(vars[v]),feasol[v], weights[v]);
- upperbound+=(feasol[v]*SCIPvarGetObj(vars[v]));
-
- }
- printf("upper bound = %f", upperbound);
-
-
+ // SCIP_Real upperbound=0;
+ // for(int v=0;v<nvars;v++)
+ // {
+ // fprintf(solutions," (%s %f weight %f) \n ", SCIPvarGetName(vars[v]),feasol[v], weights[v]);
+ // upperbound+=(feasol[v]*SCIPvarGetObj(vars[v]));
+ // SCIP_CALL( SCIPsetRelaxSolVal(scip, relax, SCIPgetVars(scip)[i], feasol[v]) );
+ // }
+ // printf("upper bound = %f\n", upperbound);
+ // SCIP_CALL( SCIPmarkRelaxSolValid(scip, relax, TRUE) );
+
@@ -615,18 +615,18 @@ SCIP_DECL_RELAXINIT(relaxInitlagr)
// SCIPinfoMessage(relaxscip, TimeCollector, "%f\n", SCIPgetClockTime(relaxscip, totaliteration));
// // if(checker==0){printf("solution found in %d iterations\n",iter); break;}
// }
- SCIPfreeTransform(relaxscip);
- fclose(variableinfo);
- fclose(dual);
- fclose(subgrad);
- fclose(varobjects);
- fclose(solutions);
- fclose(lower);
+ // SCIPfreeTransform(relaxscip);
+ // fclose(variableinfo);
+ // fclose(dual);
+ // fclose(subgrad);
+ // fclose(varobjects);
+ // fclose(solutions);
+ // fclose(lower);
- /* free memory */
- SCIPhashmapFree(&varmap);
- SCIP_CALL( SCIPfree(&relaxscip) );
+ // /* free memory */
+ // SCIPhashmapFree(&varmap);
+ // SCIP_CALL( SCIPfree(&relaxscip) );
@@ -692,7 +692,7 @@ SCIP_DECL_RELAXEXEC(relaxExeclagr)
SCIP_CONS** conss;
SCIP_PROBDATA* probdata;
SCIP_VARDATA* vardata;
-
+ SCIP_RELAXDATA* relaxdata;
SCIP_Real relaxval;
SCIP_Bool valid;
int nconss;
@@ -701,8 +701,8 @@ SCIP_DECL_RELAXEXEC(relaxExeclagr)
int id;
- *lowerbound = -SCIPinfinity(scip);
- *result = SCIP_DIDNOTRUN;
+ // *lowerbound = -SCIPinfinity(scip);
+ // *result = SCIP_DIDNOTRUN;
/* we can only run if none of the present constraints expect their variables to be binary or integer during transformation */
conss = SCIPgetConss(scip);
@@ -713,134 +713,156 @@ SCIP_DECL_RELAXEXEC(relaxExeclagr)
SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(relaxscip), SCIPgetNVars(scip)) );
valid = FALSE;
SCIP_CALL( SCIPcopy(scip, relaxscip, varmap, consmap, "relaxscip", FALSE, FALSE, FALSE, FALSE, &valid) );
-
- // /**************************************************************************************************************/
- // /*First, */
- // //*the probdata: where we get to identify the bad constraint we want to formulate(in our case, the slot conss) */
- // /***************************************************************************************************************/
- // int nvars = SCIPgetNVars(relaxscip);
- // SCIP_VAR** vars = SCIPgetVars(relaxscip);
- // SCIP_VAR** varbuffers;
- // int* badconss;
-
- // SCIPcreateprobdata(relaxscip,&probdata,SCIPgetConss(relaxscip),vars,&varbuffers,&badconss); /*will be used to identify the # of slot(bad) constraints*/
- // int nSlotConss = SCIPgetNSlotConss(probdata); //number of bad(slot) constraint
- // int allnconsvars = SCIPgetallnconsvars(probdata); //sum of all nconsvars, used for creating later on an array to collect the list of varids in each row
- // int* listnconsvars = SCIPlistnconsvars(probdata);
- // int* listconsvarids = SCIPlistconsvarids(probdata);
+
+ /**************************************************************************************************************/
+ /*First, */
+ //*the probdata: where we get to identify the bad constraint we want to formulate(in our case, the slot conss) */
+ /***************************************************************************************************************/
+ int nvars = SCIPgetNVars(relaxscip);
+ SCIP_VAR** vars = SCIPgetVars(relaxscip);
+ SCIP_VAR** varbuffers;
+ int* badconss;
- // /* we then create the vardata function for each variable, to see at which constraint the variable is found*/
- // FILE* TimeCollector;
- // TimeCollector = fopen("time.txt","w");
- // SCIP_CLOCK* varslottime; //to help us record the time
- // SCIP_CALL( SCIPcreateClock(relaxscip, &varslottime) ); //* start time counting*
- // SCIP_CALL(SCIPstartClock(relaxscip,varslottime));
+ SCIPcreateprobdata(relaxscip,&probdata,SCIPgetConss(relaxscip),vars,&varbuffers,&badconss); /*will be used to identify the # of slot(bad) constraints*/
+ int nSlotConss = SCIPgetNSlotConss(probdata); //number of bad(slot) constraint
+ int allnconsvars = SCIPgetallnconsvars(probdata); //sum of all nconsvars, used for creating later on an array to collect the list of varids in each row
+ int* listnconsvars = SCIPlistnconsvars(probdata);
+ int* listconsvarids = SCIPlistconsvarids(probdata);
+ int* increasingorder = SCIPlistincreasing(probdata);
- // // int nconsvars=0;
- // int* consids;
- // SCIP_Real* weights;
- // SCIP_CALL(SCIPallocBufferArray(relaxscip,&weights,nvars));
+ /* we then create the vardata function for each variable, to see at which constraint the variable is found*/
+ FILE* TimeCollector;
+ TimeCollector = fopen("time.txt","w");
+ FILE* solutions;
+ solutions = fopen("sol.txt","wr");
+ FILE* dual;
+ dual= fopen("dual.txt","wr");
+ FILE* variableinfo;
+ variableinfo = fopen("var.txt","wr");
+ FILE* subgrad;
+ subgrad = fopen("subgrads.txt","wr");
+ FILE* varobjects;
+ varobjects=fopen("varobjs.txt","wr");
+ FILE* lower;
+ lower=fopen("lowerbounds.txt","wr");
+ FILE* iter;
+ iter=fopen("iter.txt","wr");
- // SCIP_CALL(SCIPallocBufferArray(relaxscip,&consids,nSlotConss));
- // for (int v = 0; v < nvars; v++)
- // {
- // SCIP_VAR* var = vars[v];
- // weights[v]=SCIPvarGetObj(var);
- // }
+ SCIP_CLOCK* varslottime; //to help us record the time
+ SCIP_CALL( SCIPcreateClock(relaxscip, &varslottime) ); //* start time counting*
+ SCIP_CALL(SCIPstartClock(relaxscip,varslottime));
- // for (int v = 0; v < nvars; v++)
- // {
- // int* varids;
- // int NVarInBadConss=0;
- // int nconsvars = 0;
- // SCIP_VAR* var = vars[v];
+ SCIP_CLOCK* totaliteration; //to help us record the time
+ SCIP_CALL( SCIPcreateClock(relaxscip, &totaliteration) ); //* start time counting*
- // int varindex = SCIPvarGetIndex(var); /* (2) */
- // assert(varindex!= NULL);
- // // printf("%s****%d\n",SCIPvarGetName(var),varindex);
- // for (int r = 0; r < nSlotConss; ++r)
- // {
- // id = badconss[r];
- // SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
- // // printf("%s \t",SCIPconsGetName(cons));
- // SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
- // SCIP_CALL(SCIPgetConsVars(relaxscip, cons, varbuffers, nconsvars, &valid));
- // if (!valid){
- // abort(); }
- // for (int j = 0; j < nconsvars; ++j) /* (8) */
- // {
- // SCIP_VAR* varx = varbuffers[j];
- // int varbufindex = SCIPvarGetIndex(varx);
- // assert(varbufindex != NULL);
- // // printf("%s\t \t%d",SCIPvarGetName(varx),varbufindex);
+ int* consids;
+
+ SCIP_Real* weights;
+ SCIP_CALL(SCIPallocBufferArray(relaxscip,&weights,nvars));
+
+ SCIP_CALL(SCIPallocBufferArray(relaxscip,&consids,nSlotConss));
+
+ SCIP_Real maxobj=0;
+ for (int v = 0; v < nvars; v++)
+ {
+ SCIP_VAR* var = SCIPgetVars(scip)[v];
+ weights[v]=SCIPvarGetObj(var);
+ if(maxobj<weights[v]){maxobj=weights[v];}
+ }
+
+ for (int v = 0; v < nvars; v++)
+ {
+ int* varids;
+ int NVarInBadConss=0;
+ int nconsvars = 0;
+ SCIP_VAR* var = vars[v];
+
+ int varindex = SCIPvarGetIndex(var); /* (2) */
+ assert(varindex!= NULL);
+
+ for (int r = 0; r < nSlotConss; ++r)
+ {
+ id = badconss[r];
+ SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
+ //fprintf(solutions,"%s,%d \n",SCIPconsGetName(cons),r);
+ SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
+ SCIP_CALL(SCIPgetConsVars(relaxscip, cons, varbuffers, nconsvars, &valid));
+ if (!valid){abort(); }
+
+ for (int j = 0; j < nconsvars; ++j) /* (8) */
+ {
+ SCIP_VAR* varx = varbuffers[j];
+ int varbufindex = SCIPvarGetIndex(varx);
+ assert(varbufindex != NULL);
+ // printf("%s\t \t%d",SCIPvarGetName(varx),varbufindex);
- // /** if var[i] is in cons[c], write conspointer in VarConss and increase nVarConsscounter */
- // if (varindex == varbufindex) /* (9) */
- // {
+ /** if var[i] is in cons[c], write conspointer in VarConss and increase nVarConsscounter */
+ if (varindex == varbufindex) /* (9) */
+ {
- // // VarSlotConss[NVarInBadConss] = cons;
- // consids[NVarInBadConss]=id;
- // NVarInBadConss++;
- // // printf(" %s \t,",SCIPconsGetName(cons));
- // }
- // }
- // }
-
- // SCIP_CALL(SCIPallocBufferArray(relaxscip, &varids, NVarInBadConss));
- // for(int t=0;t<NVarInBadConss;t++)
- // {
- // varids[t]=consids[t];
- // // printf("%d \t",varids[t]);
- // }
+ // VarSlotConss[NVarInBadConss] = cons;
+ consids[NVarInBadConss]=r;
+ NVarInBadConss++;
+ // printf(" %s \t,",SCIPconsGetName(cons));
+ }
+ }
+ }
+ SCIP_CALL(SCIPallocBufferArray(relaxscip, &varids, NVarInBadConss));
+ for(int t=0;t<NVarInBadConss;t++)
+ {
+ varids[t]=consids[t];
+ // printf("%d \t",varids[t]);
+ }
+ // printf("\n");
// // vardata=SCIPvarGetData(var);
- // SCIP_CALL(SCIPallocBlockMemory(scip , &vardata));
- // SCIP_CALL(SCIPduplicateBlockMemoryArray(scip, &(vardata->varids), varids, NVarInBadConss));
- // vardata->NVarInBadConss = NVarInBadConss; /**copy nVarConss to VarData */
- // vardata->varids = varids;
- // // /**set the variable data to the variable*/
- // SCIPvarSetData(var,vardata);
- // }
+ SCIP_CALL(SCIPallocBlockMemory(scip , &vardata));
+ SCIP_CALL(SCIPduplicateBlockMemoryArray(scip, &(vardata->varids), varids, NVarInBadConss));
+ vardata->NVarInBadConss = NVarInBadConss; /**copy nVarConss to VarData */
+ vardata->varids = varids;
+ // /**set the variable data to the variable*/
+ SCIPvarSetData(var,vardata);
+ }
- // // SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
+ SCIP_CALL(SCIPstopClock(relaxscip,varslottime));
- // FILE* AfterPreProcessing;
- // AfterPreProcessing = fopen("AfterPreProcessing.txt","w+");
+ FILE* AfterPreProcessing;
+ AfterPreProcessing = fopen("AfterPreProcessing.txt","w+");
- // // SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
+ SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
- // SCIPinfoMessage(relaxscip, TimeCollector, "\n row and column identified in (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
- // for(int r=0;r<nSlotConss;r++)
- // {
- // id = badconss[r];
- // SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
- // SCIP_CALL(SCIPdelCons(relaxscip,cons));
- // }
+ SCIPinfoMessage(relaxscip, TimeCollector, "\n row and column identified in (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
+ for(int r=0;r<nSlotConss;r++)
+ {
+ id = badconss[r];
+ SCIP_CONS* cons = SCIPgetConss(relaxscip)[id];
+ SCIP_CALL(SCIPdelCons(relaxscip,cons));
+ }
- // /******************************************************************************************************************/
- // /*Next, we will do the initial iteration of finding the dual mulpliers of each slot conss, and their sum(dualsum) */
- // /* In the end, we will subtract this sum from the objective of the function. */
- // /* It's initial, because while we would search for more dual multipliers to solve the Lagrangian relaxation */
- // /******************************************************************************************************************/
- // SCIP_Real* dualmultipliers;
- // SCIP_CALL(SCIPallocBufferArray(relaxscip,&dualmultipliers,nSlotConss));
+ /******************************************************************************************************************/
+ /*Next, we will do the initial iteration of finding the dual mulpliers of each slot conss, and their sum(dualsum) */
+ /* In the end, we will subtract this sum from the objective of the function. */
+ /* It's initial, because while we would search for more dual multipliers to solve the Lagrangian relaxation */
+ /******************************************************************************************************************/
+ SCIP_Real* dualmultipliers;
+ SCIP_CALL(SCIPallocBufferArray(relaxscip,&dualmultipliers,nSlotConss));
- // SCIP_Real* subgradients;
- // SCIP_CALL(SCIPallocBufferArray(relaxscip,&subgradients,nSlotConss));
- // //initialize subgradients;
- // SCIP_Real stepsize = 1.00000;
- // SCIP_Real sumofduals=0;
- // for ( int r = 0; r < nSlotConss; ++r)
- // {
- // dualmultipliers[r] = 0;
- // sumofduals+=dualmultipliers[r]; //adds the negative of the minimum in each iteration
- // }
+ SCIP_Real* subgradients;
+ SCIP_CALL(SCIPallocBufferArray(relaxscip,&subgradients,nSlotConss));
+ //initialize subgradients;
+ SCIP_Real stepsize = 15;
+ SCIP_Real sumofduals=0;
+ for ( int r = 0; r < nSlotConss; ++r)
+ {
+ dualmultipliers[r] = 0;
+ sumofduals+=dualmultipliers[r]; //adds the negative of the minimum in each iteration
+ }
@@ -854,208 +876,346 @@ SCIP_DECL_RELAXEXEC(relaxExeclagr)
// /****************************************************************************************************************/
- // FILE* solutions;
- // solutions = fopen("sol.txt","wr");
- // FILE* dual;
- // dual= fopen("dual.txt","wr");
- // FILE* variableinfo;
- // variableinfo = fopen("var.txt","wr");
- // FILE* subgrad;
- // subgrad = fopen("subgrads.txt","wr");
- // FILE* varobjects;
- // varobjects=fopen("varobjs.txt","wr");
- // FILE* lower;
- // lower=fopen("lowerbounds.txt","wr");
- // FILE* iter;
- // lower=fopen("iter.txt","wr");
- // SCIP_Real* solvals;
- // SCIP_CALL(SCIPallocBufferArray(relaxscip,&solvals,nvars+2));
- // solvals[nvars+1]=0; //for last solutions
- // solvals[nvars]=0; //for best solution
- // int maxiter=125;
+ //fprintf(lower, "hi");
+ SCIP_Real* solvals;
+ SCIP_CALL(SCIPallocBufferArray(relaxscip,&solvals,nvars+2));
+ solvals[nvars+1]=0; //for last solutions
+ solvals[nvars]=0; //for best solution
- // int oscilatecounter=0;
- // int improvementcounter = 0;
- // SCIP_Real oscilator1=0;
- // SCIP_Real oscilator2=0;
- // SCIP_Real forcompare = 0.000;
- // fprintf(lower,"%d\n",maxiter);
- // for(int iter=1;iter<=maxiter;iter++)
- // {
+ int oscilatecounter=0;
+ int improvementcounter = 0;
+ SCIP_Real oscilator1=0;
+ SCIP_Real oscilator2=0;
+ SCIP_Real forcompare = -1000000000000000000;
+ SCIP_CALL(SCIPstartClock(relaxscip,totaliteration));
+
+ SCIP_Real* feasol;
+ SCIP_CALL(SCIPallocBufferArray(relaxscip,&feasol,nvars)); //will containt a feasible solution for our problem.
+ for(int v=0;v<nvars;v++)
+ {
+ feasol[v]=-1; //we assign initial values equal to -1, signifying that the variable's value hasn't been decided yet.
+ }
+
+
+
+ int* nvarsingoodconss;
+ SCIP_CALL(SCIPallocBufferArray(relaxscip,&nvarsingoodconss,SCIPgetNConss(relaxscip))); //will contain {9,9,9,9,9,9} for the 6f4s problem.
+
+ int maxnvarsingoodconss = 0; //max number of variables found in a start constraint
+ int nconsvars = 0; //number of vars in a startconss.
+
+ for(int r = 0; r<SCIPgetNConss(relaxscip);r++)
+ {
+ SCIP_CONS* cons = SCIPgetConss(relaxscip)[r];
+ if(SCIPconsGetLhs(relaxscip,cons,&valid)==1)
+ {
+ SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
+ if(nconsvars>maxnvarsingoodconss){maxnvarsingoodconss=nconsvars;}
+ nvarsingoodconss[r]=nconsvars;
+ }
+ }
+ // printf("%d \n",maxnvarsingoodconss);
+
+ SCIP_VAR** VARSinsidegoodconss; //will contain the variable in a start constraint
+ SCIP_CALL(SCIPallocBufferArray(relaxscip, &VARSinsidegoodconss, maxnvarsingoodconss)); //the size is the max num a start constraint can hold. We do this not to allocate memory over and over again.
+ //initialize this allocation
+ for(int v=0; v<maxnvarsingoodconss; v++)
+ {
+ VARSinsidegoodconss[v]=SCIPgetVars(relaxscip)[0];
+ }
+
+ for(int r = 0; r<SCIPgetNConss(relaxscip);r++)
+ {
- // for(int v=0;v<nvars;v++)
- // {
- // SCIP_VAR* var = vars[v];
- // double sum =0;
-
- // vardata=SCIPvarGetData(var);
- // int* varids = SCIPvardataGetvarids(vardata);
- // assert(varids=!NULL);
- // int NVarInBadConss = SCIPvardataGetNVarInBadConss(vardata);
- // if(NVarInBadConss==0){break;}
- // else
- // {
- // SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
- // fprintf(varobjects,"%s \n",SCIPvarGetName(var));
- // for(int t=0;t<NVarInBadConss;t++)
- // {
- // sum += dualmultipliers[varids[t]];
- // fprintf(varobjects,"{id = %d, dual = %f, sum = %f\t",varids[t], dualmultipliers[varids[t]],sum);
- // }
- // fprintf(varobjects,"}\n\n");
- // SCIP_CALL(SCIPaddVarObj(relaxscip,var,sum));
+ SCIP_CONS* cons = SCIPgetConss(relaxscip)[r];
+ if(SCIPconsGetLhs(relaxscip,cons,&valid)==1)
+ {
+ printf(" yes %s ",SCIPconsGetName(cons));
+ SCIP_CALL(SCIPgetConsNVars(relaxscip, cons, &nconsvars, &valid));
+ SCIP_CALL(SCIPgetConsVars(relaxscip, cons, VARSinsidegoodconss, nconsvars, &valid));
+ if (!valid){abort(); }
+ fprintf(solutions,"\n %s\n",SCIPconsGetName(cons));
+ for (int j = 0; j < nconsvars; ++j) /* (8) */
+ {
+ SCIP_VAR* varx = (VARSinsidegoodconss)[j];
+ fprintf(solutions,"%s\t",SCIPvarGetName(varx));
+ int varbufindex = SCIPvarGetIndex(varx); //get the index, which will be used in assigning values to the feassol.
+ assert(varbufindex != NULL);
+ fprintf(solutions,"%d\t",varbufindex);
- // }
-
+ if (feasol[varbufindex]==-1)
+ {
+ feasol[varbufindex]=1;
+ for(int s=j+1; s<nconsvars;++s)
+ {
+ SCIP_VAR* varnext = (VARSinsidegoodconss)[s];
+ int varnextindex = SCIPvarGetIndex(varnext);
+ feasol[varnextindex]=0;
+ }
+
+ vardata=SCIPvarGetData(varx);
+ int* varids = SCIPvardataGetvarids(vardata);
+ assert(varids=!NULL);
+ int NVarInBadConss = SCIPvardataGetNVarInBadConss(vardata);
+ fprintf(solutions,"nvarincons = %d\t",NVarInBadConss);
+
+ for(int t=0;t<NVarInBadConss;t++)
+ {
- // }
+ // fprintf(solutions,"(sid=%d, order=%d, nconsvars=%d,%d) \t",varids[t],increasingorder[varids[t]],listnconsvars[varids[t]],increasingorder[increasingorder[varids[t]]]);
+
+ // varids[t] gives the constraint address. There we still would like to find out which variables are found.
+ for(int p=increasingorder[varids[t]]-listnconsvars[varids[t]]; p<increasingorder[varids[t]]; ++p)
+ {
- // SCIPinfoMessage(relaxscip, TimeCollector, "\n finished changing the variable's weight after (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
-
- // SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,-1*sumofduals));
- // // SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
- // SCIPsetMessagehdlrQuiet(relaxscip, TRUE);
- // // fclose(AfterPreProcessing);
+ if(SCIPvarGetIndex(vars[listconsvarids[p]])!=varbufindex)
+ {
+ fprintf(solutions,"var = %s\t",SCIPvarGetName(vars[listconsvarids[p]]));
+ if(feasol[listconsvarids[p]]==-1)
+ {
+ feasol[listconsvarids[p]]=0;
+ }
+ }
+ }
+ }
+ fprintf(solutions,"\n");
+ }
- // SCIP_CALL( SCIPtransformProb(relaxscip) );
- // SCIP_CALL( SCIPsolve(relaxscip) );
- // relaxval = SCIPgetPrimalbound(relaxscip);
- // printf("\ndualbound %f \n",SCIPgetDualbound(relaxscip));
- // fprintf(lower,"%f",SCIPgetPrimalbound(relaxscip));
- // SCIPdebugMessage("relaxation bound = %e status = %d\n", relaxval, SCIPgetStatus(relaxscip));
+
+ fprintf(solutions,"(%s,%d,%f)\n",SCIPvarGetName(varx), varbufindex,feasol[varbufindex]);
- // /*store the highest lower bound*/
- // if(solvals[nvars]<SCIPgetPrimalbound(relaxscip)){solvals[nvars]=SCIPgetPrimalbound(relaxscip);fprintf(variableinfo,}
- // fprintf(variableinfo,"%f\n",solvals[nvars]);
+
+
+ }
+ fprintf(solutions,"\n");
+ }
+
+ }
- // /*make sure we're not oscilating by adding a counter, which checks the absolute value between the difference of the previous few steps and make sure it's not the same. */
- // oscilator2=abs(solvals[nvars+1]-SCIPgetPrimalbound(relaxscip));
- // if(oscilator1==oscilator2){oscilatecounter++;}
- // else(oscilator1=oscilator2);
- // if(oscilatecounter==5){printf("repetition"); break;}
- // printf("dprev.sol=%f, current=%f, difference %f, coutner=%d, ",solvals[nvars+1],SCIPgetPrimalbound(relaxscip), oscilator2, oscilatecounter);
+
+ SCIP_Real upperbound=0;
+ for(int v=0;v<nvars;v++)
+ {
+ SCIP_VAR* var = SCIPgetVars(scip)[v];
+ fprintf(solutions," (%s %f weight %f) \n ", SCIPvarGetName(vars[v]),feasol[v], weights[v]);
+ upperbound+=(feasol[v]*SCIPvarGetObj(vars[v]));
+ // SCIPsetSolVal(scip,relaxdata->sol,var,feasol[v]);
+ SCIP_CALL(SCIPsetRelaxSolVal(scip, relax, SCIPgetVars(scip)[i], feasol[v]) ); //setting the solutions found here for the main scip problem.
+ }
+ printf("upper bound = %f\n", upperbound);
+ SCIP_CALL( SCIPmarkRelaxSolValid(scip, relax, TRUE) );
+
+
+ SCIP_Real change=0;//for saving the dual solution of previous.
+ int maxiter=130;
+ int stopping = 0;
+ for(int iter=1;iter<=maxiter;iter++)
+ {
- // /*store the solution on the last entry of solvals, so we can compare it in the next round for repetitions*/
- // solvals[nvars+1]=SCIPgetPrimalbound(relaxscip);
+ for(int v=0;v<nvars;v++)
+ {
+ SCIP_VAR* var = vars[v];
+ double sum =0;
+
+ vardata=SCIPvarGetData(var);
+ int* varids = SCIPvardataGetvarids(vardata);
+ assert(varids=!NULL);
+ int NVarInBadConss = SCIPvardataGetNVarInBadConss(vardata);
+ // if(NVarInBadConss==0){SCIPsetSolVal(relaxscip,) break;}
+ // else
+ // {
+ // SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
+ // fprintf(varobjects,"%s \n",SCIPvarGetName(var));
+ for(int t=0;t<NVarInBadConss;t++)
+ {
+ sum += dualmultipliers[varids[t]];
+ // fprintf(varobjects,"{id = %d, dual = %f, sum = %f\t",varids[t], dualmultipliers[varids[t]],sum);
+ }
+ // fprintf(varobjects,"}\n\n");
+ SCIP_CALL(SCIPaddVarObj(relaxscip,var,sum));
- // /*breaking criteria for iterations*/
- // if(solvals[nvars]>forcompare){forcompare=solvals[nvars];}
- // else{improvementcounter++;}
- // if(improvementcounter==5){break;}
+ // }
+
+
+ }
- // /*get the best solution*/
- // SCIP_SOL* bestsol = SCIPgetBestSol(relaxscip) ;
- // SCIP_SOL** sols = SCIPgetSols(relaxscip);
- // int nsols = SCIPgetNSols(relaxscip);
+ SCIPinfoMessage(relaxscip, TimeCollector, "\n finished changing the variable's weight after (sec) : %f\n", SCIPgetClockTime(relaxscip, totaliteration));
+
+ SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,-1*sumofduals));
+ //SCIP_CALL(SCIPprintOrigProblem(relaxscip, AfterPreProcessing, "lp", FALSE));
+ SCIPsetMessagehdlrQuiet(relaxscip, TRUE);
+ // fclose(AfterPreProcessing);
+
+ SCIP_CALL( SCIPtransformProb(relaxscip) );
+ SCIP_CALL( SCIPsolve(relaxscip) );
+ // relaxval = SCIPgetPrimalbound(relaxscip);
+ //printf("\ndualbound %f \n",SCIPgetDualbound(relaxscip));
+ fprintf(lower,"%f\n",SCIPgetPrimalbound(relaxscip));
+ // SCIPdebugMessage("relaxation bound = %e status = %d\n", relaxval, SCIPgetStatus(relaxscip));
+
+ /*store the highest lower bound*/
+ if(solvals[nvars]<SCIPgetPrimalbound(relaxscip)){solvals[nvars]=SCIPgetPrimalbound(relaxscip);}
+
+
+ /*make sure we're not oscilating by adding a counter, which checks the absolute value between the difference of the previous few steps and make sure it's not the same. */
+ oscilator2=abs(solvals[nvars+1]-SCIPgetPrimalbound(relaxscip));
+ if(oscilator1==oscilator2){oscilatecounter++;}
+ else{oscilator1=oscilator2; oscilatecounter==0;}
+ //if(oscilatecounter==5){printf("repetition"); break;}
+ //printf("dprev.sol=%f, current=%f, difference %f, coutner=%d, ",solvals[nvars+1],SCIPgetPrimalbound(relaxscip), oscilator2, oscilatecounter);
+
+ /*store the solution on the last entry of solvals, so we can compare it in the next round for repetitions*/
+ solvals[nvars+1]=SCIPgetPrimalbound(relaxscip);
+
+ /*breaking criteria for iterations*/
+ if(solvals[nvars]>forcompare){forcompare=solvals[nvars]; improvementcounter=0;}
+ else{improvementcounter++;}
+ //if(improvementcounter==10){break; fprintf(variableinfo,"%d\n",iter);}
+ printf("terminator %d",improvementcounter);
+
+ /*get the best solution*/
+ SCIP_SOL* bestsol = SCIPgetBestSol(relaxscip) ;
+ SCIP_SOL** sols = SCIPgetSols(relaxscip);
+ int nsols = SCIPgetNSols(relaxscip);
+
+ //fprintf(lower,"%d iteration \n",iter);
+ for(int n=0; n<nsols; n++)
+ {
+ //SCIP_CALL(SCIPprintSol(relaxscip,sols[n],lower,FALSE));
+ }
- // /*text output*/
- // SCIPinfoMessage(relaxscip, TimeCollector, "\n first iteration: problem solved after (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
- // fprintf(solutions,"number of solutions %d, first iteration \t bound=%f, \t objsol=%f \n",nsols, SCIPgetPrimalbound(relaxscip),relaxval);
- // // SCIP_CALL(SCIPprintBestSol(relaxscip,solutions,FALSE));
+ /*text output*/
+ //SCIPinfoMessage(relaxscip, TimeCollector, "\n first iteration: problem solved after (sec) : %f\n", SCIPgetClockTime(relaxscip, totaliteration));
+ //fprintf(solutions,"number of solutions %d, first iteration \t bound=%f, \t objsol=%f \n",nsols, SCIPgetPrimalbound(relaxscip),relaxval);
+ // SCIP_CALL(SCIPprintBestSol(relaxscip,solutions,FALSE));
- // /*store the solution in solvals so we can later export it to subgradient function*/
- // SCIP_Real lowerbound=0;
- // SCIPgetSolVals(relaxscip,bestsol,nvars,vars,solvals);
- // SCIP_CALL(SCIPprintSol(relaxscip,bestsol,dual,FALSE));
+ /*store the solution in solvals so we can later export it to subgradient function*/
+ SCIP_Real lowerbound=0;
+ SCIPgetSolVals(relaxscip,bestsol,nvars,vars,solvals);
+ //SCIP_CALL(SCIPprintSol(relaxscip,bestsol,dual,FALSE));
- // SCIP_Real compare=0;
- // for (int v = 0; v<nvars; ++v)
- // {
- // compare += solvals[v]*weights[v];
- // }
+ SCIP_Real compare=0;
+ for (int v = 0; v<nvars; ++v)
+ {
+ compare += solvals[v]*weights[v];
+ }
- // // stepsize = 15/double(iter+1);
- // // fprintf(solutions, "\niteration %d\n",iter);
- // // fprintf(dual, "\niteration %d\n",iter);
- // // fprintf(variableinfo, "\niteration %d\n",iter);
- // // fprintf(varobjects, "\niteration %d\n",iter);
- // SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,sumofduals));
- // // SCIP_CALL( SCIPfreeTransform(relaxscip) );
- // // SCIP_CALL( SCIPtransformProb(relaxscip) );
+ //stepsize = (stepsize+iter)/double(iter+1);
+ // fprintf(solutions, "\niteration %d\n",iter);
+ // fprintf(dual, "\niteration %d\n",iter);
+ // fprintf(variableinfo, "\niteration %d\n",iter);
+ // fprintf(varobjects, "\niteration %d\n",iter);
- // counter = 0;
- // int checker = 0;
- // for(int r=0; r<nSlotConss;++r)
- // {
- // id = badconss[r];
- // double ax=-1;
- // for(int s=counter;s<(counter+listnconsvars[r]);++s)
- // {
- // // printf("%s->",SCIPvarGetName(vars[listconsvarids[s]]));
- // ax+=SCIPgetSolVal(relaxscip,bestsol,vars[listconsvarids[s]]);
- // // fprintf(subgrad,"%s\t,%f\t, sum %f",SCIPvarGetName(vars[listconsvarids[s]]),SCIPgetSolVal(relaxscip,bestsol,vars[listconsvarids[s]]),ax);
+ SCIP_CALL(SCIPaddOrigObjoffset(relaxscip,sumofduals));
+ // SCIP_CALL( SCIPfreeTransform(relaxscip) );
+ // SCIP_CALL( SCIPtransformProb(relaxscip) );
+
+ counter = 0;
+ int checker = 0;
+ for(int r=0; r<nSlotConss;++r)
+ {
+ id = badconss[r];
+ double ax=-1;
+ for(int s=counter;s<(counter+listnconsvars[r]);++s)
+ {
+ // printf("%s->",SCIPvarGetName(vars[listconsvarids[s]]));
+ ax+=SCIPgetSolVal(relaxscip,bestsol,vars[listconsvarids[s]]);
+ // fprintf(subgrad,"%s\t,%f\t, sum %f",SCIPvarGetName(vars[listconsvarids[s]]),SCIPgetSolVal(relaxscip,bestsol,vars[listconsvarids[s]]),ax);
- // }
+ }
- // counter += listnconsvars[r];
- // if(ax>0){checker++;}
- // subgradients[r]=ax;
- // // fprintf(subgrad, "\n subgrad = %f \t",subgradients[r]);
+ counter += listnconsvars[r];
+ if(ax>0){checker++;}
+ subgradients[r]=ax;
+ // fprintf(subgrad, "\n subgrad = %f \t",subgradients[r]);
- // }
- // /*breaking condition on finding a feasible solution*/
- // if(checker==0){printf("#*#*#*result found\n"); break;}
+ }
+ /*breaking condition on finding a feasible solution*/
+ if(checker==0){printf("#*#*#*result found\n"); break;}
- // SCIP_CALL( SCIPfreeTransform(relaxscip) );
- // SCIP_CALL( SCIPtransformProb(relaxscip) );
+ SCIP_CALL( SCIPfreeTransform(relaxscip) );
+ SCIP_CALL( SCIPtransformProb(relaxscip) );
- // for (int v = 0; v<nvars; ++v)
- // {
- // SCIP_VAR* var = vars[v];
+ for (int v = 0; v<nvars; ++v)
+ {
+ SCIP_VAR* var = vars[v];
- // SCIP_CALL(SCIPchgVarObj(relaxscip,var,weights[v]));
- // // fprintf(variableinfo,"(%s,%f,%f)->%f\n",SCIPvarGetName(var),solvals[v],SCIPvarGetObj(var), weights[v]);
- // lowerbound += solvals[v]*weights[v];
- // }
- // // fprintf(dual,"dualbound = %f, lowerbound=%f, norm of subgrad %f\t",SCIPgetPrimalbound(relaxscip),lowerbound, getnorm(subgradients,nSlotConss,stepsize));
- // // fprintf(lower,"%f\n",lowerbound);
+ SCIP_CALL(SCIPchgVarObj(relaxscip,var,weights[v]));
+
+ // fprintf(variableinfo,"(%s,%f,%f)->%f\n",SCIPvarGetName(var),solvals[v],SCIPvarGetObj(var), weights[v]);
+ lowerbound += solvals[v]*weights[v];
+ }
+ // fprintf(dual,"dualbound = %f, lowerbound=%f, norm of subgrad %f\t",SCIPgetPrimalbound(relaxscip),lowerbound, getnorm(subgradients,nSlotConss,stepsize));
+ // fprintf(lower,"%f\n",lowerbound);
- // // stepsize = (SCIPgetPrimalbound(relaxscip)-lowerbound)/getnorm(subgradients,nSlotConss,stepsize);
- // SCIP_CALL( SCIPfreeTransform(relaxscip) );
- // fprintf(solutions, "lowerbound = %f \n ", lowerbound);
- // SCIPinfoMessage(relaxscip, TimeCollector, "\n subgradients found after (sec) : %f\n, lowerbound = %f \n", SCIPgetClockTime(relaxscip, varslottime),lowerbound);
- // //add back the sum of the duals we subtracted from the main obj function
+ SCIP_Real difference = 1500000-SCIPgetPrimalbound(relaxscip);
+ SCIP_Real progress = SCIPgetPrimalbound(relaxscip)-change;
+ printf("\t %f\n",progress);
+
+ // if(difference>1)
+ // {
+ // if(improvementcounter<5){stepsize = -2*(difference)/(getnorm(subgradients,nSlotConss,stepsize)*getnorm(subgradients,nSlotConss,stepsize));}
+ // else{stepsize =-1*(difference)/(getnorm(subgradients,nSlotConss,stepsize)*getnorm(subgradients,nSlotConss,stepsize));}
+ // }
+ // else{stepsize=1;}
+ if(progress<0.1){stepsize=stepsize/iter; stopping++;}
+ stepsize = 1;
+ if(stopping==3){ break;}
+ fprintf(dual,"dualbound = %f, lowerbound=%f, norm of subgrad %f\t stepsize= %f \n" ,SCIPgetPrimalbound(relaxscip),lowerbound, getnorm(subgradients,nSlotConss,stepsize), stepsize);
+ change = SCIPgetPrimalbound(relaxscip);
+ fprintf(variableinfo,"%f\n",solvals[nvars]);
+ SCIP_CALL( SCIPfreeTransform(relaxscip) );
+ // fprintf(solutions, "lowerbound = %f \n ", lowerbound);
+ //SCIPinfoMessage(relaxscip, TimeCollector, "\n subgradients found after (sec) : %f\n, lowerbound = %f \n", SCIPgetClockTime(relaxscip, varslottime),lowerbound);
+
+ //add back the sum of the duals we subtracted from the main obj function
- // int sum=0;
- // sumofduals = 0;
+ int sum=0;
+ sumofduals = 0;
- // for(int r=0; r<nSlotConss;++r)
- // {
- // dualmultipliers[r] += subgradients[r]*stepsize;
- // if(dualmultipliers[r]<0){dualmultipliers[r]=0;}
+ for(int r=0; r<nSlotConss;++r)
+ {
+ dualmultipliers[r] += subgradients[r]*stepsize;
+ if(dualmultipliers[r]<0){dualmultipliers[r]=0;}
- // sum+=dualmultipliers[r];
- // // fprintf(dual," then %f step size %f \n",dualmultipliers[r], stepsize);
- // }
- // sumofduals=sum;
- // // fprintf(dual,"iteration %d, sumofduals=%f\n",iter, sumofduals);
- // SCIPinfoMessage(relaxscip, TimeCollector, "\n new dual found after (sec) : %f\n", SCIPgetClockTime(relaxscip, varslottime));
- // // if(checker==0){printf("solution found in %d iterations\n",iter); break;}
- // }
- // SCIPfreeTransform(relaxscip);
- // fclose(variableinfo);
- // fclose(dual);
- // fclose(subgrad);
- // fclose(varobjects);
- // fclose(solutions);
- // fclose(lower);
+ sumofduals+=dualmultipliers[r];
+ //fprintf(dual," then dual = %f step size %f, subgradient %f \n",dualmultipliers[r], stepsize,subgradients[r]);
+ }
+ // sumofduals=sum;
+ // fprintf(dual,"iteration %d, sumofduals=%f\n",iter, sumofduals);
+ SCIPinfoMessage(relaxscip, TimeCollector, "%f\n", SCIPgetClockTime(relaxscip, totaliteration));
+ // if(checker==0){printf("solution found in %d iterations\n",iter); break;}
+ }
+ SCIPfreeTransform(relaxscip);
+ fclose(variableinfo);
+ fclose(dual);
+ fclose(subgrad);
+ fclose(varobjects);
+ fclose(solutions);
+ fclose(lower);
+ *lowerbound = solvals[nvars];
+ *result = SCIP_SUCCESS;
+ printf("\nis it solved %d\n",SCIPisRelaxSolValid(scip));
+ relaxval = solvals[nvars];
+ SCIPdebugMessage("relaxation bound = %e status = %d\n", relaxval, SCIPgetStatus(relaxscip));
+
if( SCIPgetStatus(relaxscip) == SCIP_STATUS_OPTIMAL )
{
/* store relaxation solution in original SCIP if it improves the best relaxation solution thus far */
diff --git a/time.txt b/time.txt
index 91b260f8002e5259d9bc08a50607a2b0e60ae492..144124ab04d0b00af00b6ad13841b2db6eb4dc00 100644
--- a/time.txt
+++ b/time.txt
@@ -1,2 +1,67 @@
- row and column identified in (sec) : 0.000252
+ row and column identified in (sec) : 0.000162
+
+ finished changing the variable's weight after (sec) : 0.000941
+0.006116
+
+ finished changing the variable's weight after (sec) : 0.006164
+0.020437
+
+ finished changing the variable's weight after (sec) : 0.020603
+0.029869
+
+ finished changing the variable's weight after (sec) : 0.030062
+0.052249
+
+ finished changing the variable's weight after (sec) : 0.052727
+0.083780
+
+ finished changing the variable's weight after (sec) : 0.084110
+0.100559
+
+ finished changing the variable's weight after (sec) : 0.100606
+0.134207
+
+ finished changing the variable's weight after (sec) : 0.134376
+0.170888
+
+ finished changing the variable's weight after (sec) : 0.170987
+0.189907
+
+ finished changing the variable's weight after (sec) : 0.190397
+0.214879
+
+ finished changing the variable's weight after (sec) : 0.215035
+0.248610
+
+ finished changing the variable's weight after (sec) : 0.249024
+0.276051
+
+ finished changing the variable's weight after (sec) : 0.276489
+0.305234
+
+ finished changing the variable's weight after (sec) : 0.305363
+0.331501
+
+ finished changing the variable's weight after (sec) : 0.331629
+0.365271
+
+ finished changing the variable's weight after (sec) : 0.365548
+0.392237
+
+ finished changing the variable's weight after (sec) : 0.392345
+0.416936
+
+ finished changing the variable's weight after (sec) : 0.417094
+0.448937
+
+ finished changing the variable's weight after (sec) : 0.449053
+0.480631
+
+ finished changing the variable's weight after (sec) : 0.481091
+0.520802
+
+ finished changing the variable's weight after (sec) : 0.520921
+0.540580
+
+ finished changing the variable's weight after (sec) : 0.540629
diff --git a/var.txt b/var.txt
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..9650a2a3c9f47e4e7195848dd6012ee533078d88 100644
--- a/var.txt
+++ b/var.txt
@@ -0,0 +1,21 @@
+1.000000
+14.000000
+27.000000
+40.000000
+50.000000
+51.000000
+51.000000
+54.000000
+58.000000
+59.000000
+59.000000
+62.000000
+63.000000
+63.000000
+65.000000
+65.000000
+67.000000
+68.000000
+73.000000
+74.000000
+74.000000