def __init__(self, path, mode):
filename = "table-results-" + str(mode) + '.tex'
self.file = TextFileWriter(path, filename)
self.gzip = (mode == 2)
self.__print_start()
self.current_dataset, self.current_filename = None, None
self.last_dataset, self.last_filename = None, None
def _create_latex_file(self, filename, data_lines):
output = TextFileWriter(self.path, filename)
output.write_line(r"\begin{table}[h]")
for line in LatexUtils.print_commands():
output.write_line(line)
first_lines = [
r"\newcommand{\best}{\cellcolor{gray!30}}", r"\centering"
r"\hspace*{0cm}\begin{tabular}{| l | c | c | c | c | c | c | c | c |}"
r"\cline{2-9}"
r"\multicolumn{1}{c|}{}& \multicolumn{8}{c|}{maxRD (\%)}\\\hline"
]
last_lines = [
r"\end{tabular}", r"\caption{\captionminmaxone}"
if self.mode == 1 else r"\caption{\captionminmaxtwo}",
r"\label{experiments:minmaxone}" if self.mode == 1 else
r"\label{experiments:minmaxtwo}", r"\end{table}"
]
ordered_data_lines = [data_lines[0]] # Column names
for algorithm in self.ORDER:
for line in data_lines:
first, last = line.find("{"), line.find("}")
if algorithm == line[first + 1:last]:
ordered_data_lines.append(line)
for line in first_lines + ordered_data_lines + last_lines:
output.write_line(line)
class TableRelative(object):
FILENAME = "table-relative.tex"
def __init__(self, datasets_data, path):
self.datasets_data = datasets_data
self.writer = TextFileWriter(path, self.FILENAME)
def create_table(self):
reader = TextFileReader(os.path.dirname(__file__), '_begin.tex')
self.writer.append_file(reader)
for name in LatexUtils.DATASETS_ORDER:
line = self.generate_dataset_line(name)
self.writer.write_line(line)
reader = TextFileReader(os.path.dirname(__file__), '_end.tex')
self.writer.append_file(reader)
self.writer.close()
def generate_dataset_line(self, name):
data = self.datasets_data[name]
dataset_key = LatexUtils.get_dataset_key(name)
gaps_info = ExperimentsUtils.get_gaps_info(name)
assert (data['zero'] == 0)
total = data['negative'] + data['positive']
percentage = MathUtils.calculate_percentage(total, data['positive'], 2)
percentage = int(percentage) if int(
percentage) == percentage else round(percentage, 1)
outperform_str = str(data['positive']) + "/" + str(total) + " (" + str(
percentage) + "\%)"
range_str = self.range_str(data)
return LatexUtils.format_line(
[dataset_key, gaps_info, outperform_str, range_str])
@staticmethod
def range_str(data):
min_str = str(round(data['min'], 2))
max_str = str(round(data['max'], 2))
max_zero = max_str == "-0.0"
if max_zero:
max_str = "0"
if data['info'] == "PlotMin":
assert (min_str == "-0.29")
min_str = TableRelative.color_value(min_str, 'blue')
elif data['info'] == "PlotMax":
assert (max_str == "50.78")
max_str = TableRelative.color_value(max_str, 'red')
return "[" + min_str + "; " + max_str + (")" if max_zero else "]")
@staticmethod
def color_value(value, color):
return r"\textcolor{" + color + "}{" + value + "}"
class TableWindows(object):
FILENAME = "table-windows.tex"
def __init__(self, algorithms_data, path):
self.algorithms_data = algorithms_data
self.writer = TextFileWriter(path, self.FILENAME)
def create_table(self):
reader = TextFileReader(os.path.dirname(__file__), '_begin.tex')
self.writer.append_file(reader)
for name in self.algorithms_data.keys():
print(name)
print("---")
line = self.generate_algorithm_line(name)
self.writer.write_line(line)
reader = TextFileReader(os.path.dirname(__file__), '_end.tex')
self.writer.append_file(reader)
self.writer.close()
def generate_algorithm_line(self, name):
data = self.algorithms_data[name]
name = name.replace("Coder", "") # "CoderGAMPSLimit" => "CoderGAMPS"
name = name.replace("Limit", "") # "CoderGAMPS" => "GAMPS"
total = sum(data)
expected_total = 8*200 if name == "Total" else 200
# print(data)
# print(name)
# print(total)
# print(expected_total)
assert(total == expected_total)
line = [name]
total_percentage = 0
for value in data:
percentage = MathUtils.calculate_percentage(total, value, 1)
if name == "Total" and round(percentage,1) == 89.6:
percentage = 89.5
percentage = int(percentage) if int(percentage) == percentage else percentage
total_percentage += percentage
value_str = str(format(value,',d'))
if value_str != "0":
value_str += " (" + str(percentage) + "\%)"
line.append(value_str)
line = LatexUtils.format_line(line)
if name == "GAMPS": # last line before total
line += "\hline"
# print(name)
# print(round(total_percentage,1))
assert(round(total_percentage,1) == 100.0)
return line
def __init__(self, datasets_data, path):
self.datasets_data = datasets_data
self.writer = TextFileWriter(path, self.FILENAME)
def __init__(self, algorithms_data, path):
self.algorithms_data = algorithms_data
self.writer = TextFileWriter(path, self.FILENAME)
class LatexTable(object):
PATH = OSUtils.python_project_path(
) + "/scripts/informe/latex_tables/table_datasets/output"
def __init__(self, filename):
self.file = TextFileWriter(self.PATH, filename)
def add_data_irkis(self, data):
array = [
data['name'],
LatexUtils.thousands(data['rows']),
LatexUtils.thousands(data['columns']),
LatexUtils.thousands(data['total_entries']),
self.add_spaces(LatexTable.nan_total(data), "224,287 (85.3)"),
self.add_spaces(str(int(data['min'])), "128"),
int(data['max']),
int(data['median']),
LatexUtils.round(data['mean']),
self.add_spaces(LatexUtils.round(data['stdev']), "119.7")
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
def add_data_sst(self, data):
array = [
data['name'],
LatexUtils.thousands(data['rows']),
LatexUtils.thousands(data['columns']),
LatexUtils.thousands(data['total_entries']),
LatexTable.nan_total(data),
int(data['min']),
LatexUtils.thousands(int(data['max'])),
LatexUtils.thousands(int(data['median'])),
LatexUtils.round_thousands(data['mean']),
LatexUtils.round_thousands(data['stdev'])
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
def add_data_adcp(self, data):
array = [
data['name'],
LatexUtils.thousands(data['rows']),
LatexUtils.thousands(data['columns']),
LatexUtils.thousands(data['total_entries']),
LatexTable.nan_total(data),
int(data['min']),
LatexUtils.thousands(int(data['max'])),
LatexUtils.thousands(int(data['median'])),
LatexUtils.round_thousands(data['mean']),
LatexUtils.round_thousands(data['stdev'])
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
def add_data_elnino(self, data):
assert (LatexUtils.thousands(data['rows']) == "6,371")
assert (LatexUtils.thousands(data['columns']) == "78")
assert (LatexUtils.thousands(data['total_entries']) == "496,938")
array = [
data['name'],
LatexTable.nan_total(data),
self.add_spaces2(LatexUtils.thousands(int(data['min'])),
"-18,000"),
self.add_spaces2(LatexUtils.thousands(int(data['max'])), "17,108"),
self.add_spaces2(LatexUtils.thousands(int(data['median'])),
"-11,126"),
self.add_spaces2(LatexUtils.round_thousands(data['mean']),
"-5,402.5"),
self.add_spaces2(LatexUtils.round_thousands(data['stdev']),
"13,536.4")
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
def add_data_hail(self, data):
assert (LatexUtils.thousands(data['rows']) == "17,059")
assert (LatexUtils.thousands(data['columns']) == "1")
assert (LatexUtils.thousands(data['total_entries']) == "17,059")
array = [
data['name'],
LatexTable.nan_total(data),
self.add_spaces3(LatexUtils.thousands(int(data['min'])),
"-12,442"),
self.add_spaces3(LatexUtils.thousands(int(data['max'])), "-6,783"),
self.add_spaces3(LatexUtils.thousands(int(data['median'])),
"-9,676"),
self.add_spaces3(LatexUtils.round_thousands(data['mean']),
"-9,487.4"),
self.add_spaces2(LatexUtils.round_thousands(data['stdev']),
"841.4")
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
def add_data_tornado(self, data):
assert (LatexUtils.thousands(data['rows']) == "3,841")
assert (LatexUtils.thousands(data['columns']) == "1")
assert (LatexUtils.thousands(data['total_entries']) == "3,841")
array = [
data['name'],
LatexTable.nan_total(data),
self.add_spaces3(LatexUtils.thousands(int(data['min'])),
"-12,397"),
self.add_spaces3(LatexUtils.thousands(int(data['max'])), "-6,822"),
self.add_spaces3(LatexUtils.thousands(int(data['median'])),
"-9,313"),
self.add_spaces3(LatexUtils.round_thousands(data['mean']),
"-9,260.0"),
self.add_spaces2(LatexUtils.round_thousands(data['stdev']),
"787.9")
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
def add_data_wind(self, data):
assert (LatexUtils.thousands(data['rows']) == "40,260")
assert (LatexUtils.thousands(data['columns']) == "1")
assert (LatexUtils.thousands(data['total_entries']) == "40,260")
array = [
data['name'],
LatexTable.nan_total(data),
self.add_spaces3(LatexUtils.thousands(int(data['min'])),
"-12,432"),
self.add_spaces2(LatexUtils.thousands(int(data['max'])), "2,359"),
self.add_spaces3(LatexUtils.thousands(int(data['median'])),
"-8,732"),
self.add_spaces3(LatexUtils.round_thousands(data['mean']),
"-8,870.1"),
self.add_spaces2(LatexUtils.round_thousands(data['stdev']),
"968.4")
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
def add_data_solar(self, data):
assert (LatexUtils.thousands(data['rows']) == "8,759")
assert (LatexUtils.thousands(data['columns']) == "12")
assert (LatexUtils.thousands(data['total_entries']) == "105,108")
array = [
data['name'],
LatexTable.nan_total(data, 2),
self.add_spaces2(LatexUtils.thousands(int(data['min'])), "0"),
self.add_spaces4(LatexUtils.thousands(int(data['max'])), "1,005"),
self.add_spaces4(LatexUtils.thousands(int(data['median'])), "11"),
self.add_spaces4(LatexUtils.round_thousands(data['mean']),
"187.6"),
self.add_spaces2(LatexUtils.round_thousands(data['stdev']),
"274.7")
]
table_row = LatexUtils.array_to_table_row(array, False)
self.file.write_line(table_row)
@classmethod
def nan_total(cls, data, round_=1):
rounded = LatexUtils.round(data['nan_percentage'], round_)
return LatexUtils.thousands(data['nan_total']) + " (" + rounded + ")"
@classmethod
def add_spaces(cls, string, expected):
assert (len(string) <= len(expected))
expected_length = len(expected) # "224,287 (85.3)" => 14
spaces = "\ " * 2 * (expected_length - len(string))
return spaces + string
@classmethod
def add_spaces2(cls, string, expected):
assert (len(string) <= len(expected))
expected_length = len(expected) # "224,287 (85.3)" => 14
spaces = "\ " * 1 * (expected_length - len(string))
spaces = spaces + "\ " if len(string) != len(expected) else spaces
return spaces + string
@classmethod
def add_spaces3(cls, string, expected):
assert (len(string) <= len(expected))
expected_length = len(expected) # "224,287 (85.3)" => 14
spaces = "\ " * 1 * (expected_length - len(string))
spaces = spaces + "\ " if len(string) != len(expected) else spaces
spaces = spaces + "\ " if "-" in string else spaces
spaces = spaces + "\ " if len(string) == 3 else spaces
spaces = spaces + "\ " * 2 if string == "0" else spaces
return spaces + string
@classmethod
def add_spaces4(cls, string, expected):
assert (len(string) <= len(expected))
expected_length = len(expected) # "224,287 (85.3)" => 14
spaces = "\ " * 1 * (expected_length - len(string))
spaces = spaces + "\ " if len(string) != len(expected) else spaces
spaces = spaces + "\ " if "-" in string else spaces
spaces = spaces + "\ " if string == "11" else spaces
return spaces + string
def close(self):
self.file.close()
def __init__(self, filename):
self.file = TextFileWriter(self.PATH, filename)
class TableCompression(object):
THRE_COUNT = len(ExperimentsUtils.THRESHOLDS)
WINDOW_MAP = {0: '', 4: 2, 8: 3, 16: 4, 32: 5, 64: 6, 128: 7, 256: 8}
def __init__(self, path, mode):
filename = "table-results-" + str(mode) + '.tex'
self.file = TextFileWriter(path, filename)
self.gzip = (mode == 2)
self.__print_start()
self.current_dataset, self.current_filename = None, None
self.last_dataset, self.last_filename = None, None
def set_dataset(self, dataset_name):
# print "set_dataset => " + dataset_name
self.current_dataset = dataset_name
self.last_dataset = dataset_name
def set_filename(self, filename):
# print "set_filename => " + filename
self.current_filename = filename
self.last_filename = filename
def set_threshold_results(self, threshold_results):
# [None, None, 'Lat', 'PCA', 256, 100.03, 'PCA', 256, 100.03, 'APCA', 4, 88.74, 'APCA', 4, 81.29, 'APCA', 4, 69.82, 'APCA', 8, 62.44, 'APCA', 8, 56.18, 'APCA', 8, 47.15]
# print("set_threshold_results => " + str(threshold_results))
assert (len(threshold_results) == 3 + self.THRE_COUNT * 3)
dataset_str = ''
if self.current_dataset is not None:
dataset_str = LatexUtils.get_dataset_key(self.current_dataset)
self.current_dataset = None
line_list = [dataset_str, threshold_results[2]]
for i in range(self.THRE_COUNT):
index_begin = 3 * (i + 1) # 3, 6, 9, ...
coder = threshold_results[index_begin]
coder_style = LatexUtils.coder_style(coder)
window_value = threshold_results[index_begin + 1]
window_x = self.WINDOW_MAP.get(window_value) or ''
cr = threshold_results[index_begin + 2]
cr = format(cr, '.2f')
threshold_list = self.two_columns(False, coder_style + cr,
coder_style + str(window_x))
line_list += threshold_list
line = LatexUtils.array_to_table_row(line_list)
self.__write_line(line)
####################################################################################################################
def __write_line(self, line):
self.file.write_line(line)
def __print_start(self):
self.__write_line(r"\begin{table}[h]")
for line in LatexUtils.print_commands():
self.__write_line(line)
self.__write_line("\centering")
self.__write_line(self.__legend_for_mode())
self.__write_line(r"\hspace*{-2.1cm}\begin{tabular}{| l | l " +
("| c | c |" * self.THRE_COUNT) + "}")
self.__write_line("\cline{3-" + str(self.THRE_COUNT * 2 + 2) + "}")
self.__write_line(self.threshold_line())
columns = self.two_columns(True)
self.__write_line("{Dataset} & {Data Type}" +
(columns * self.THRE_COUNT) + r" \\\hline\hline")
@staticmethod
def add_gzip_result(threshold_results, gzip_cr):
# [None, None, 'Lat', 'PCA', 256, 100.03, 'PCA', 256, 100.03, ... ]
current_index = 5
last_index = len(threshold_results) - 1
while current_index <= last_index:
cr = threshold_results[current_index]
if gzip_cr < cr:
threshold_results[current_index] = gzip_cr
threshold_results[current_index - 1] = 0 # no window value
threshold_results[current_index - 2] = 'GZIP'
elif gzip_cr == cr:
raise ValueError
current_index += 3
def threshold_line(self):
line = "\multicolumn{1}{c}{}& \multicolumn{1}{c|}{} "
column = "& \multicolumn{2}{c|"
for thre in ExperimentsUtils.THRESHOLDS:
line += column + ("|" if thre != 30 else
"") + "}{e = " + str(thre) + "} "
line += r"\\\hline"
return line
def print_end(self):
lines = [
r"\end{tabular}", r"\caption{" + self.__caption_for_mode() + "}",
r"\label{experiments:mask-results-overview" +
self.__label_for_mode() + "}", r"\end{table}"
]
for line in lines:
self.__write_line(line)
def two_columns(self, header=False, cr=None, w=None):
if header:
return r" & {\footnotesize CR} & {\footnotesize w}"
return [cr, w]
def __caption_for_mode(self):
return "\captiontwo" if self.gzip else "\captionone"
def __label_for_mode(self):
return "2" if self.gzip else "1"
def __legend_for_mode(self):
return "\legendstwo" if self.gzip else "\legendsone"
def _save_results(self, stds, thresholds_array):
writer = TextFileWriter(self.script_path, self.STDS_FILENAME,
"a") # "a" = append mode
writer.write_line(self.input_filename) # vwc_1202.dat.csv
writer.write_line(json.dumps(
stds)) # [0, 15.067395786326722, ... , 10.242778426186861]
writer.write_line(
json.dumps(thresholds_array)
) # [{"percentage": 0.0, "values": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}, ... , {"percentage": 0.3, "values": [0, 5, 6, 3, 4, 2, 3, 3, 2, 7, 3]}]
writer.write_line('')
writer.close()