···

       
13
       
 
       
import re

     

       
14
       
 
       
import sys

     

       
15
       
 
       


     

       
0
       
 
       

     

       
16
       
 
       
def compute_area(file, time):

     

       
17
       
 
       
    area = -1

     

       
18
       
 
       


     
···

       
25
       
 
       
        # if match:

     

       
26
       
 
       
        #     objectives.append(int(match[1]))

     

       
27
       
 
       
        #     continue

     

       
28
       
-
       
        match = re.match(r'objective\s=\s(\d+)', line)

     

       
29
       
 
       
        if match:

     

       
30
       
 
       
            objectives.append(int(match[1]))

     

       
31
       
 
       
            continue

     

       
32
       
-
       
        match = re.match(r'%\stime elapsed:\s(\d+)\sms', line)

     

       
33
       
 
       
        if match:

     

       
34
       
 
       
            times.append(int(match[1]))

     

       
35
       
 
       
            continue

     

       
36
       
 
       
    times.append(time)

     

       
37
       
 
       


     

       
38
       
-
       
    assert(len(objectives) > 0)

     

       
39
       
-
       
    assert(len(objectives)+1 == len(times))

     

       
40
       
 
       
    area = 0

     

       
41
       
 
       
    for i in range(len(objectives)):

     

       
42
       
-
       
        area += ((times[i+1] - times[i])/1000)*objectives[i]

     

       
43
       
 
       
    return int(area)

     

       
0
       
 
       

     

       
44
       
 
       


     

       
45
       
 
       
folder = sys.argv[1]

     

       
46
       
 
       
stats = {}

     

       
47
       
 
       
for root, dirs, files in os.walk(folder):

     

       
48
       
 
       
    for name in files:

     

       
49
       
-
       
        if name.endswith('.sol'):

     

       
50
       
 
       
            seed = 1

     

       
51
       
 
       
            match = re.search(r"\.(\d+)\.sol", name)

     

       
52
       
 
       
            if match:

     
···

       
59
       
 
       
                # Nodes

     

       
60
       
 
       
                match = re.search(r"nodes:\s+(\d+)", line)

     

       
61
       
 
       
                if match:

     

       
62
       
-
       
                    statistics['nodes'] = int(match.group(1))

     

       
63
       
 
       
                    continue

     

       
64
       
 
       
                # Solve time

     

       
65
       
 
       
                match = re.search(r"search time:\s+(\d+\.\d+)\s*seconds", line)

     

       
66
       
 
       
                if match:

     

       
67
       
-
       
                    statistics['search_time'] = int(float(match.group(1))*1000)

     

       
68
       
 
       
                    continue

     

       
69
       
 
       
                # Restarts

     

       
70
       
 
       
                match = re.search(r"restart count:\s+(\d+)", line)

     

       
71
       
 
       
                if match:

     

       
72
       
-
       
                    statistics['restarts'] = int(match.group(1))

     

       
73
       
 
       
                    continue

     

       
74
       
 
       


     

       
75
       
 
       
            for line in contents[::-1]:

     

       
76
       
 
       
                # Best objective

     

       
77
       
-
       
                match = re.match(r'objective\s=\s(\d+)', line)

     

       
78
       
 
       
                if match:

     

       
79
       
-
       
                    statistics['objective'] = int(match[1])

     

       
80
       
 
       
                    break

     

       
81
       
 
       
            # Area

     

       
82
       
-
       
            area = compute_area(contents, statistics['search_time'])

     

       
83
       
 
       


     

       
84
       
-
       
            stats[name[:-(4)].replace(".", ",")] = (area, statistics['objective'], statistics['search_time'], statistics['restarts'], statistics['nodes'])

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
85
       
 
       


     

       
86
       
 
       
sorted_stats = sorted(stats.items())

     

       
87
       
-
       
a = sorted_stats[0][0][:sorted_stats[0][0].find(",")]

     

       
88
       
 
       
for key, val in sorted_stats:

     

       
89
       
-
       
    if key[:key.find(",")] != a:

     

       
90
       
 
       
        print("\n\n")

     

       
91
       
-
       
        a = key[:key.find(",")]

     

       
92
       
 
       
    print("%s,%s" % (key, ",".join([v.__str__() for v in val])))

     

       
93
       
 
       


     

       
94
       
 
       
exit(1)

     

···

       
13
       
 
       
import re

     

       
14
       
 
       
import sys

     

       
15
       
 
       


     

       
16
       
+
       


     

       
17
       
 
       
def compute_area(file, time):

     

       
18
       
 
       
    area = -1

     

       
19
       
 
       


     
···

       
26
       
 
       
        # if match:

     

       
27
       
 
       
        #     objectives.append(int(match[1]))

     

       
28
       
 
       
        #     continue

     

       
29
       
+
       
        match = re.match(r"objective\s=\s(\d+)", line)

     

       
30
       
 
       
        if match:

     

       
31
       
 
       
            objectives.append(int(match[1]))

     

       
32
       
 
       
            continue

     

       
33
       
+
       
        match = re.match(r"%\stime elapsed:\s(\d+)\sms", line)

     

       
34
       
 
       
        if match:

     

       
35
       
 
       
            times.append(int(match[1]))

     

       
36
       
 
       
            continue

     

       
37
       
 
       
    times.append(time)

     

       
38
       
 
       


     

       
39
       
+
       
    assert len(objectives) > 0

     

       
40
       
+
       
    assert len(objectives) + 1 == len(times)

     

       
41
       
 
       
    area = 0

     

       
42
       
 
       
    for i in range(len(objectives)):

     

       
43
       
+
       
        area += ((times[i + 1] - times[i]) / 1000) * objectives[i]

     

       
44
       
 
       
    return int(area)

     

       
45
       
+
       


     

       
46
       
 
       


     

       
47
       
 
       
folder = sys.argv[1]

     

       
48
       
 
       
stats = {}

     

       
49
       
 
       
for root, dirs, files in os.walk(folder):

     

       
50
       
 
       
    for name in files:

     

       
51
       
+
       
        if name.endswith(".sol"):

     

       
52
       
 
       
            seed = 1

     

       
53
       
 
       
            match = re.search(r"\.(\d+)\.sol", name)

     

       
54
       
 
       
            if match:

     
···

       
61
       
 
       
                # Nodes

     

       
62
       
 
       
                match = re.search(r"nodes:\s+(\d+)", line)

     

       
63
       
 
       
                if match:

     

       
64
       
+
       
                    statistics["nodes"] = int(match.group(1))

     

       
65
       
 
       
                    continue

     

       
66
       
 
       
                # Solve time

     

       
67
       
 
       
                match = re.search(r"search time:\s+(\d+\.\d+)\s*seconds", line)

     

       
68
       
 
       
                if match:

     

       
69
       
+
       
                    statistics["search_time"] = int(float(match.group(1)) * 1000)

     

       
70
       
 
       
                    continue

     

       
71
       
 
       
                # Restarts

     

       
72
       
 
       
                match = re.search(r"restart count:\s+(\d+)", line)

     

       
73
       
 
       
                if match:

     

       
74
       
+
       
                    statistics["restarts"] = int(match.group(1))

     

       
75
       
 
       
                    continue

     

       
76
       
 
       


     

       
77
       
 
       
            for line in contents[::-1]:

     

       
78
       
 
       
                # Best objective

     

       
79
       
+
       
                match = re.match(r"objective\s=\s(\d+)", line)

     

       
80
       
 
       
                if match:

     

       
81
       
+
       
                    statistics["objective"] = int(match[1])

     

       
82
       
 
       
                    break

     

       
83
       
 
       
            # Area

     

       
84
       
+
       
            area = compute_area(contents, statistics["search_time"])

     

       
85
       
 
       


     

       
86
       
+
       
            stats[name[:-(4)].replace(".", ",")] = (

     

       
87
       
+
       
                area,

     

       
88
       
+
       
                statistics["objective"],

     

       
89
       
+
       
                statistics["search_time"],

     

       
90
       
+
       
                statistics["restarts"],

     

       
91
       
+
       
                statistics["nodes"],

     

       
92
       
+
       
            )

     

       
93
       
 
       


     

       
94
       
 
       
sorted_stats = sorted(stats.items())

     

       
95
       
+
       
a = sorted_stats[0][0][: sorted_stats[0][0].find(",")]

     

       
96
       
 
       
for key, val in sorted_stats:

     

       
97
       
+
       
    if key[: key.find(",")] != a:

     

       
98
       
 
       
        print("\n\n")

     

       
99
       
+
       
        a = key[: key.find(",")]

     

       
100
       
 
       
    print("%s,%s" % (key, ",".join([v.__str__() for v in val])))

     

       
101
       
 
       


     

       
102
       
 
       
exit(1)

     

···

       
13
       
 
       
import re

     

       
14
       
 
       
import sys

     

       
15
       
 
       


     

       
0
       
 
       

     

       
16
       
 
       
def compute_area(file):

     

       
17
       
 
       
    area = -1

     

       
18
       
 
       


     
···

       
25
       
 
       
        # if match:

     

       
26
       
 
       
        #     objectives.append(int(match[1]))

     

       
27
       
 
       
        #     continue

     

       
28
       
-
       
        match = re.match(r'objective\s=\s(\d+)', line)

     

       
29
       
 
       
        if match:

     

       
30
       
 
       
            objectives.append(int(match[1]))

     

       
31
       
 
       
            continue

     

       
32
       
-
       
        match = re.match(r'%\stime elapsed:\s(\d+)\sms', line)

     

       
33
       
 
       
        if match:

     

       
34
       
 
       
            times.append(int(match[1]))

     

       
35
       
 
       
            continue

     
···

       
38
       
 
       
            times.append(int(match.group(1)))

     

       
39
       
 
       
            continue

     

       
40
       
 
       


     

       
41
       
-
       
    assert(len(objectives) > 0)

     

       
42
       
-
       
    assert(len(objectives)+1 == len(times))

     

       
43
       
 
       
    area = 0

     

       
44
       
 
       
    for i in range(len(objectives)):

     

       
45
       
-
       
        area += ((times[i+1] - times[i])/1000)*objectives[i]

     

       
46
       
 
       
    return int(area)

     

       
47
       
 
       


     

       
48
       
-
       
folder = sys.argv[1]

     

       
0
       
 
       

     

       
49
       
 
       
statistics = {}

     

       
50
       
 
       
for root, dirs, files in os.walk(folder):

     

       
51
       
 
       
    for name in files:

     

       
52
       
-
       
        if name.endswith('.sol'):

     

       
53
       
 
       
            seed = 1

     

       
54
       
 
       
            match = re.search(r"\.(\d+)\.sol", name)

     

       
55
       
 
       
            if match:

     
···

       
59
       
 
       
            # Area

     

       
60
       
 
       
            area = compute_area(contents)

     

       
61
       
 
       


     

       
62
       
-
       
            objective = 'UNSAT'

     

       
63
       
 
       
            for line in contents[::-1]:

     

       
64
       
 
       
                # Best objective

     

       
65
       
-
       
                match = re.match(r'objective\s=\s(\d+)', line)

     

       
66
       
 
       
                if match:

     

       
67
       
 
       
                    objective = int(match[1])

     

       
68
       
 
       
                    break

     
···

       
86
       
 
       
                if match:

     

       
87
       
 
       
                    restarts = int(match.group(1))

     

       
88
       
 
       
                    continue

     

       
89
       
-
       
            statistics[name[:-(4)].replace(".", ",")] = (area, objective, solvetime, restarts, nodes)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
90
       
 
       


     

       
91
       
 
       
sorted_stats = sorted(statistics.items())

     

       
92
       
-
       
a = sorted_stats[0][0][:sorted_stats[0][0].find(",")]

     

       
93
       
 
       
for key, val in sorted_stats:

     

       
94
       
-
       
    if key[:key.find(",")] != a:

     

       
95
       
 
       
        print("\n\n")

     

       
96
       
-
       
        a = key[:key.find(",")]

     

       
97
       
 
       
    print("%s,%s" % (key, ",".join([v.__str__() for v in val])))

     

       
98
       
 
       


     

       
99
       
 
       
exit(1)

     

···

       
13
       
 
       
import re

     

       
14
       
 
       
import sys

     

       
15
       
 
       


     

       
16
       
+
       


     

       
17
       
 
       
def compute_area(file):

     

       
18
       
 
       
    area = -1

     

       
19
       
 
       


     
···

       
26
       
 
       
        # if match:

     

       
27
       
 
       
        #     objectives.append(int(match[1]))

     

       
28
       
 
       
        #     continue

     

       
29
       
+
       
        match = re.match(r"objective\s=\s(\d+)", line)

     

       
30
       
 
       
        if match:

     

       
31
       
 
       
            objectives.append(int(match[1]))

     

       
32
       
 
       
            continue

     

       
33
       
+
       
        match = re.match(r"%\stime elapsed:\s(\d+)\sms", line)

     

       
34
       
 
       
        if match:

     

       
35
       
 
       
            times.append(int(match[1]))

     

       
36
       
 
       
            continue

     
···

       
39
       
 
       
            times.append(int(match.group(1)))

     

       
40
       
 
       
            continue

     

       
41
       
 
       


     

       
42
       
+
       
    assert len(objectives) > 0

     

       
43
       
+
       
    assert len(objectives) + 1 == len(times)

     

       
44
       
 
       
    area = 0

     

       
45
       
 
       
    for i in range(len(objectives)):

     

       
46
       
+
       
        area += ((times[i + 1] - times[i]) / 1000) * objectives[i]

     

       
47
       
 
       
    return int(area)

     

       
48
       
 
       


     

       
49
       
+
       


     

       
50
       
+
       
foler = sys.argv[1]

     

       
51
       
 
       
statistics = {}

     

       
52
       
 
       
for root, dirs, files in os.walk(folder):

     

       
53
       
 
       
    for name in files:

     

       
54
       
+
       
        if name.endswith(".sol"):

     

       
55
       
 
       
            seed = 1

     

       
56
       
 
       
            match = re.search(r"\.(\d+)\.sol", name)

     

       
57
       
 
       
            if match:

     
···

       
61
       
 
       
            # Area

     

       
62
       
 
       
            area = compute_area(contents)

     

       
63
       
 
       


     

       
64
       
+
       
            objective = "UNSAT"

     

       
65
       
 
       
            for line in contents[::-1]:

     

       
66
       
 
       
                # Best objective

     

       
67
       
+
       
                match = re.match(r"objective\s=\s(\d+)", line)

     

       
68
       
 
       
                if match:

     

       
69
       
 
       
                    objective = int(match[1])

     

       
70
       
 
       
                    break

     
···

       
88
       
 
       
                if match:

     

       
89
       
 
       
                    restarts = int(match.group(1))

     

       
90
       
 
       
                    continue

     

       
91
       
+
       
            statistics[name[:-(4)].replace(".", ",")] = (

     

       
92
       
+
       
                area,

     

       
93
       
+
       
                objective,

     

       
94
       
+
       
                solvetime,

     

       
95
       
+
       
                restarts,

     

       
96
       
+
       
                nodes,

     

       
97
       
+
       
            )

     

       
98
       
 
       


     

       
99
       
 
       
sorted_stats = sorted(statistics.items())

     

       
100
       
+
       
a = sorted_stats[0][0][: sorted_stats[0][0].find(",")]

     

       
101
       
 
       
for key, val in sorted_stats:

     

       
102
       
+
       
    if key[: key.find(",")] != a:

     

       
103
       
 
       
        print("\n\n")

     

       
104
       
+
       
        a = key[: key.find(",")]

     

       
105
       
 
       
    print("%s,%s" % (key, ",".join([v.__str__() for v in val])))

     

       
106
       
 
       


     

       
107
       
 
       
exit(1)