diff --git a/UserConfig.json b/UserConfig.json index 4754c4fd9..1a0c68378 100644 --- a/UserConfig.json +++ b/UserConfig.json @@ -1,4 +1,5 @@ { + "save_csv_as_bin": false, "matmul_vec_size_bits": 0, "matmul_tile": false, "matmul_use_fixed_tile_sizes": true, diff --git a/containers/entrypoint-interactive.sh b/containers/entrypoint-interactive.sh index 5d63841ca..19799fbad 100755 --- a/containers/entrypoint-interactive.sh +++ b/containers/entrypoint-interactive.sh @@ -15,6 +15,29 @@ # limitations under the License. /usr/sbin/sshd -f /etc/ssh/sshd_config + + +# Allow root login and password authentication +sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config +sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config +sed -i 's/KbdInteractiveAuthentication no/KbdInteractiveAuthentication yes/' /etc/ssh/sshd_config +sed -i 's/ChallengeResponseAuthentication no/ChallengeResponseAuthentication yes/' /etc/ssh/sshd_config + +# Allow port forwarding +sed -i 's/#AllowTcpForwarding yes/AllowTcpForwarding yes/' /etc/ssh/sshd_config +sed -i 's/#GatewayPorts no/GatewayPorts yes/' /etc/ssh/sshd_config + +#enable logging +sed -i 's/#SyslogFacility AUTH/SyslogFacility AUTH/' /etc/ssh/sshd_config +sed -i 's/#LogLevel INFO/LogLevel INFO/' /etc/ssh/sshd_config + +# Uncomment the Port 22 line +sed -i 's/#Port 22/Port 22/' /etc/ssh/sshd_config + +echo "root:x" | chpasswd + +/usr/sbin/sshd -D & + /usr/sbin/groupadd -g "$GID" dockerusers /usr/sbin/useradd -c 'Docker Container User' -u $UID -g "$GID" -G sudo -m -s /bin/bash -d /home/"$USER" "$USER" printf "${USER} ALL=(ALL:ALL) NOPASSWD:ALL" | sudo EDITOR="tee -a" visudo #>> /dev/null @@ -23,8 +46,8 @@ chmod 700 /home/"$USER"/.ssh touch /home/"$USER"/.sudo_as_admin_successful # set a default password SALT=$(date +%M%S) -PASS=Docker!"$SALT" -echo "${USER}":"$PASS" | chpasswd +PASS=x # Docker!"1234" +#echo "${USER}":"$PASS" | chpasswd echo echo For longer running containers consider running \'unminimize\' to update packages echo and make the container more suitable for interactive use. @@ -33,5 +56,15 @@ echo "Use "$USER" with password "$PASS" for SSH login" echo "Docker Container IP address(es):" awk '/32 host/ { print f } {f=$2}' <<< "$((); + registry.insert(); // Add the following to include *all* MLIR Core dialects, or selectively // include what you need like above. You only need to register dialects that // will be *parsed* by the tool, not the one generated // registerAllDialects(registry); - return mlir::asMainReturnCode(mlir::MlirOptMain( - argc, argv, "Standalone DAPHNE optimizing compiler driver\n", - registry)); + return mlir::asMainReturnCode( + mlir::MlirOptMain(argc, argv, "Standalone DAPHNE optimizing compiler driver\n", registry)); } diff --git a/doc/docs-build-requirements.txt b/doc/docs-build-requirements.txt index 383793d74..4c8f017dd 100644 --- a/doc/docs-build-requirements.txt +++ b/doc/docs-build-requirements.txt @@ -1 +1 @@ -mkdocs-material +mkdocs-material diff --git a/evaluation/build-charts.py b/evaluation/build-charts.py new file mode 100644 index 000000000..3f5984584 --- /dev/null +++ b/evaluation/build-charts.py @@ -0,0 +1,137 @@ +import glob +import re +import os +import pandas as pd +import matplotlib.pyplot as plt +import numpy as np + +# Folder where logs are stored. +results_dir = './results' + +# This function extracts dimensions (number of rows and columns) from the filename. +# e.g. "frame_100000r_20c_MIXED.csv" -> (100000,20) +def extract_dims(filename): + m = re.search(r'(\d+)r_(\d+)c', filename) + if m: + rows = int(m.group(1)) + cols = int(m.group(2)) + return rows, cols + else: + return None, None + +# This function extracts the overall data type from the filename. +# It considers the main type (matrix if the filename starts with "matrix_", +# otherwise frame) combined with a subtype (mixed, str, float, etc.). +def extract_data_type(filename): + base = os.path.basename(filename) + main_type = "matrix" if base.startswith("matrix_") else "frame" + m = re.search(r'(mixed|str|float|rep|strdiff|fixedstr|number)', base, re.IGNORECASE) + subtype = m.group(1).lower() if m else "unknown" + # Map fixedstr and strdiff to "str" for comparison purposes + if subtype in ["fixedstr", "strdiff"]: + subtype = "str" + return f"{main_type}_{subtype}" + +# Load CSV logs for each experiment. +def load_log(experiment, pattern): + # We assume files are named like evaluation_results_*_{experiment}.csv in the results folder. + files = glob.glob(os.path.join(results_dir, f"evaluation_results_*_{experiment}.csv")) + dfs = [] + for f in files: + # The CSV already has a header: + # CSVFile,Experiment,Trial,ReadTime,WriteTime,dbdfReadTime,StartupSeconds,ParsingSeconds,CompilationSeconds,ExecutionSeconds,TotalSeconds + df = pd.read_csv(f) + # Extract dimensions and add them as columns. + dims = df['CSVFile'].apply(lambda x: extract_dims(x)) + df['Rows'] = dims.apply(lambda x: x[0] if x else np.nan) + df['Cols'] = dims.apply(lambda x: x[1] if x else np.nan) + # Compute a size measure (for example, total cells) + df['Size'] = df['Rows'] * df['Cols'] + # Extract a combined data type (main type and subtype). + df['DataType'] = df['CSVFile'].apply(extract_data_type) + dfs.append(df) + if dfs: + return pd.concat(dfs, ignore_index=True) + else: + return pd.DataFrame() + +# Load the three experiment logs. +df_normal = load_log("normal", "evaluation_results_*_normal.csv") +df_create = load_log("create", "evaluation_results_*_create.csv") +df_opt = load_log("opt", "evaluation_results_*_opt.csv") + +# Compute average timings per dataset (grouped by CSVFile, Size, Rows, Cols, and DataType) +def aggregate_log(df): + # Convert timing fields to numeric type. + cols_to_numeric = ['ReadTime', 'WriteTime', + 'StartupSeconds', 'ParsingSeconds', 'CompilationSeconds', + 'ExecutionSeconds', 'TotalSeconds'] + for col in cols_to_numeric: + df[col] = pd.to_numeric(df[col], errors='coerce') + # Group including DataType so that it is preserved in the aggregation. + return df.groupby(['CSVFile', 'Size', 'Rows', 'Cols', 'DataType'])[cols_to_numeric].mean().reset_index() + +agg_normal = aggregate_log(df_normal) +agg_create = aggregate_log(df_create) +agg_opt = aggregate_log(df_opt) + +# Plot 1: Overall read time comparison for Normal, First (Create) and Second (Opt) reads. +plt.figure(figsize=(10,6)) +agg_normal = agg_normal.sort_values("Size") +agg_create = agg_create.sort_values("Size") +agg_opt = agg_opt.sort_values("Size") + +plt.plot(agg_normal["Size"], agg_normal["ReadTime"], marker="o", label="Normal Read") +plt.plot(agg_create["Size"], agg_create["ReadTime"], marker="s", label="First Read (Overall)") +plt.plot(agg_opt["Size"], agg_opt["ReadTime"], marker="^", label="Second Read (Overall)") +plt.xlabel("Dataset Size (Rows x Cols)") +plt.ylabel("Overall Read Time (seconds)") +plt.title("Overall Read Time vs Dataset Size") +plt.xscale("log") # Added: logarithmic scale on x-axis. +plt.yscale("log") # Added: logarithmic scale on y-axis. +plt.legend() +plt.grid(True, which="both", ls="--") +plt.tight_layout() +plt.savefig("fig/overall_read_time.png") +plt.close() + +# Plot 2: Three read comparison per dataset size for each data type. +unique_types = agg_normal["DataType"].unique() +for dt in unique_types: + sub_normal = agg_normal[agg_normal["DataType"] == dt].sort_values("Size") + sub_create = agg_create[agg_create["DataType"] == dt].sort_values("Size") + sub_opt = agg_opt[agg_opt["DataType"] == dt].sort_values("Size") + + plt.figure(figsize=(10,6)) + plt.plot(sub_normal["Size"], sub_normal["ReadTime"], marker="o", label="Normal Read") + plt.plot(sub_create["Size"], sub_create["ReadTime"], marker="s", label="First Read (Overall)") + plt.plot(sub_opt["Size"], sub_opt["ReadTime"], marker="^", label="Second Read (Overall)") + plt.xlabel("Dataset Size (Rows x Cols)") + plt.ylabel("Overall Read Time (seconds)") + plt.title(f"Overall Read Time vs Dataset Size for {dt}") + plt.xscale("log") # Added: logarithmic scale on x-axis. + plt.yscale("log") # Added: logarithmic scale on y-axis. + plt.legend() + plt.grid(True, which="both", ls="--") + plt.tight_layout() + plt.savefig(f"fig/overall_read_time_{dt}.png") + plt.close() + +# Plot 3: Breakdown for First Read (Create) – Stacked bar: Overall Read Time and dbdf Write Time. +if not agg_create.empty: + ind = np.arange(len(agg_create)) + width = 0.6 + fig, ax = plt.subplots(figsize=(10,6)) + p1 = ax.bar(ind, agg_create["ReadTime"], width, label="Overall Read Time") + p2 = ax.bar(ind, agg_create["WriteTime"], width, bottom=agg_create["ReadTime"], label="dbdf Write Time") + ax.set_xticks(ind) + ax.set_xticklabels(agg_create["CSVFile"], rotation=45, ha="right") + ax.set_ylabel("Time (seconds)") + ax.set_title("First Read Breakdown (Create): Read vs. Write dbdf") + ax.legend() + plt.tight_layout() + plt.savefig("fig/create_read_breakdown.png") + plt.close() + + +print("Charts generated and saved as PNG files.") \ No newline at end of file diff --git a/evaluation/create_csv.py b/evaluation/create_csv.py new file mode 100644 index 000000000..0b2357c61 --- /dev/null +++ b/evaluation/create_csv.py @@ -0,0 +1,119 @@ +import argparse +import csv +import json +import numpy as np +import pandas as pd +import random +import string + +def random_string(length=5): + s = ''.join(random.choices(string.ascii_letters, k=length)) + return s.replace(',', '\\') + +def fixed_str_16(): + s = ''.join(random.choices(string.ascii_letters + string.digits, k=16)) + return s.replace(',', '\\') + +def generate_column_data(typ, num_rows): + if typ == "uint8": + return np.random.randint(0, 256, num_rows, dtype=np.uint8) + elif typ == "int8": + return np.random.randint(-128, 128, num_rows, dtype=np.int8) + elif typ == "uint32": + return np.random.randint(0, 10000, num_rows, dtype=np.uint32) + elif typ == "int32": + return np.random.randint(-1000, 1000, num_rows, dtype=np.int32) + elif typ == "uint64": + return np.random.randint(0, 10000, num_rows, dtype=np.uint64) + elif typ == "int64": + return np.random.randint(-10000, 10000, num_rows, dtype=np.int64) + elif typ == "float32": + return np.random.rand(num_rows).astype(np.float32) + elif typ == "float64": + return np.random.rand(num_rows).astype(np.float64) + elif typ == "str": + # Note: generating strings is inherently less vectorized. + return np.array([random_string(random.randint(3, 8)) for _ in range(num_rows)], dtype=str) + elif typ == "fixedstr16": + return np.array([fixed_str_16() for _ in range(num_rows)], dtype=str) + else: + raise ValueError(f"Unsupported type: {typ}") + +def main(): + parser = argparse.ArgumentParser(description="Generate a CSV with variable types in each column.") + parser.add_argument("--rows", type=int, default=10, help="Number of rows") + parser.add_argument("--cols", type=int, default=7, help="Number of columns") + parser.add_argument("--output", type=str, default="", help="Output CSV file name") + parser.add_argument("--type", type=str, default="NUMBER", choices=["INT", "FLOAT", "NUMBER", "STR", "FIXEDSTR", "MIXED"], + help="CSV type; allowed values: INT, FLOAT, NUMBER, STR, FIXEDSTR, MIXED") + args = parser.parse_args() + + + # Based on the selected type set the column types for generation. + csv_type = args.type.upper() + if csv_type == "INT": + col_types = ["uint8", "int8", "uint32", "int32", "uint64", "int64"] + elif csv_type == "FLOAT": + col_types = ["float32", "float64"] + elif csv_type == "NUMBER": + col_types = ["uint8", "int8", "uint32", "int32", "uint64", "int64", "float32", "float64"] + elif csv_type == "STR": + col_types = ["str"] + elif csv_type == "FIXEDSTR": + col_types = ["fixedstr16"] + elif csv_type == "MIXED": + col_types = ["uint8", "int8", "uint32", "int32", "uint64", "int64", "float32", "float64", "str", "fixedstr16"] + else: + raise ValueError(f"Unknown CSV type: {csv_type}") + + # Build output filename such that evaluator can later extract row/col counts and type. + if not args.output: + args.output = f"data_{args.rows}r_{args.cols}c_{csv_type}.csv" + + # Mapping to convert internal type string to meta file valueType. + type_mapping = { + "uint8": "ui8", + "int8": "si8", + "uint32": "ui32", + "int32": "si32", + "uint64": "ui64", + "int64": "si64", + "float32": "f32", + "float64": "f64", + "str": "str", + "fixedstr16": "fixedstr16" + } + + # Generate each column using vectorized operations. + data = {} + schema = [] + for c in range(args.cols): + typ = col_types[c % len(col_types)] + col_name = f"col_{c}_{typ}" + data[col_name] = generate_column_data(typ, args.rows) + schema.append({ + "label": col_name, + "valueType": type_mapping[typ] + }) + + # Create a DataFrame from the generated data. + df = pd.DataFrame(data) + + # Write CSV file using pandas which leverages lower-level C code + df.to_csv(args.output, index=False, header=False) + print(f"CSV file '{args.output}' with {args.rows} rows and {args.cols} columns created.") + + + # Create meta data. + meta = { + "numRows": args.rows, + "numCols": args.cols, + "schema": schema + } + meta_filename = f"{args.output}.meta" + with open(meta_filename, mode="w") as metafile: + json.dump(meta, metafile, indent=4) + print(f"Meta file '{meta_filename}' created.") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/evaluation/data/frame_100000r_20c_MIXED.csv.meta b/evaluation/data/frame_100000r_20c_MIXED.csv.meta new file mode 100644 index 000000000..4409cf155 --- /dev/null +++ b/evaluation/data/frame_100000r_20c_MIXED.csv.meta @@ -0,0 +1,86 @@ +{ + "numRows": 100000, + "numCols": 20, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_str", + "valueType": "str" + }, + { + "label": "col_9_fixedstr16", + "valueType": "str" + }, + { + "label": "col_10_uint8", + "valueType": "ui8" + }, + { + "label": "col_11_int8", + "valueType": "si8" + }, + { + "label": "col_12_uint32", + "valueType": "ui32" + }, + { + "label": "col_13_int32", + "valueType": "si32" + }, + { + "label": "col_14_uint64", + "valueType": "ui64" + }, + { + "label": "col_15_int64", + "valueType": "si64" + }, + { + "label": "col_16_float32", + "valueType": "f32" + }, + { + "label": "col_17_float64", + "valueType": "f64" + }, + { + "label": "col_18_str", + "valueType": "str" + }, + { + "label": "col_19_fixedstr16", + "valueType": "str" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_100000r_20c_NUMBER.csv.meta b/evaluation/data/frame_100000r_20c_NUMBER.csv.meta new file mode 100644 index 000000000..d39e3d63c --- /dev/null +++ b/evaluation/data/frame_100000r_20c_NUMBER.csv.meta @@ -0,0 +1,86 @@ +{ + "numRows": 100000, + "numCols": 20, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_uint8", + "valueType": "ui8" + }, + { + "label": "col_9_int8", + "valueType": "si8" + }, + { + "label": "col_10_uint32", + "valueType": "ui32" + }, + { + "label": "col_11_int32", + "valueType": "si32" + }, + { + "label": "col_12_uint64", + "valueType": "ui64" + }, + { + "label": "col_13_int64", + "valueType": "si64" + }, + { + "label": "col_14_float32", + "valueType": "f32" + }, + { + "label": "col_15_float64", + "valueType": "f64" + }, + { + "label": "col_16_uint8", + "valueType": "ui8" + }, + { + "label": "col_17_int8", + "valueType": "si8" + }, + { + "label": "col_18_uint32", + "valueType": "ui32" + }, + { + "label": "col_19_int32", + "valueType": "si32" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_10000r_20c_MIXED.csv.meta b/evaluation/data/frame_10000r_20c_MIXED.csv.meta new file mode 100644 index 000000000..c6553f130 --- /dev/null +++ b/evaluation/data/frame_10000r_20c_MIXED.csv.meta @@ -0,0 +1,86 @@ +{ + "numRows": 10000, + "numCols": 20, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_str", + "valueType": "str" + }, + { + "label": "col_9_fixedstr16", + "valueType": "str" + }, + { + "label": "col_10_uint8", + "valueType": "ui8" + }, + { + "label": "col_11_int8", + "valueType": "si8" + }, + { + "label": "col_12_uint32", + "valueType": "ui32" + }, + { + "label": "col_13_int32", + "valueType": "si32" + }, + { + "label": "col_14_uint64", + "valueType": "ui64" + }, + { + "label": "col_15_int64", + "valueType": "si64" + }, + { + "label": "col_16_float32", + "valueType": "f32" + }, + { + "label": "col_17_float64", + "valueType": "f64" + }, + { + "label": "col_18_str", + "valueType": "str" + }, + { + "label": "col_19_fixedstr16", + "valueType": "str" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_10000r_20c_NUMBER.csv.meta b/evaluation/data/frame_10000r_20c_NUMBER.csv.meta new file mode 100644 index 000000000..3e9fa9b04 --- /dev/null +++ b/evaluation/data/frame_10000r_20c_NUMBER.csv.meta @@ -0,0 +1,86 @@ +{ + "numRows": 10000, + "numCols": 20, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_uint8", + "valueType": "ui8" + }, + { + "label": "col_9_int8", + "valueType": "si8" + }, + { + "label": "col_10_uint32", + "valueType": "ui32" + }, + { + "label": "col_11_int32", + "valueType": "si32" + }, + { + "label": "col_12_uint64", + "valueType": "ui64" + }, + { + "label": "col_13_int64", + "valueType": "si64" + }, + { + "label": "col_14_float32", + "valueType": "f32" + }, + { + "label": "col_15_float64", + "valueType": "f64" + }, + { + "label": "col_16_uint8", + "valueType": "ui8" + }, + { + "label": "col_17_int8", + "valueType": "si8" + }, + { + "label": "col_18_uint32", + "valueType": "ui32" + }, + { + "label": "col_19_int32", + "valueType": "si32" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_1000r_10c_MIXED.csv.meta b/evaluation/data/frame_1000r_10c_MIXED.csv.meta new file mode 100644 index 000000000..e51621b1d --- /dev/null +++ b/evaluation/data/frame_1000r_10c_MIXED.csv.meta @@ -0,0 +1,46 @@ +{ + "numRows": 1000, + "numCols": 10, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_str", + "valueType": "str" + }, + { + "label": "col_9_fixedstr16", + "valueType": "str" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_1000r_10c_NUMBER.csv.meta b/evaluation/data/frame_1000r_10c_NUMBER.csv.meta new file mode 100644 index 000000000..82fdf0e86 --- /dev/null +++ b/evaluation/data/frame_1000r_10c_NUMBER.csv.meta @@ -0,0 +1,46 @@ +{ + "numRows": 1000, + "numCols": 10, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_uint8", + "valueType": "ui8" + }, + { + "label": "col_9_int8", + "valueType": "si8" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_5000000r_100c_MIXED.csv.meta b/evaluation/data/frame_5000000r_100c_MIXED.csv.meta new file mode 100644 index 000000000..79a6c5095 --- /dev/null +++ b/evaluation/data/frame_5000000r_100c_MIXED.csv.meta @@ -0,0 +1,406 @@ +{ + "numRows": 5000000, + "numCols": 100, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_str", + "valueType": "str" + }, + { + "label": "col_9_fixedstr16", + "valueType": "str" + }, + { + "label": "col_10_uint8", + "valueType": "ui8" + }, + { + "label": "col_11_int8", + "valueType": "si8" + }, + { + "label": "col_12_uint32", + "valueType": "ui32" + }, + { + "label": "col_13_int32", + "valueType": "si32" + }, + { + "label": "col_14_uint64", + "valueType": "ui64" + }, + { + "label": "col_15_int64", + "valueType": "si64" + }, + { + "label": "col_16_float32", + "valueType": "f32" + }, + { + "label": "col_17_float64", + "valueType": "f64" + }, + { + "label": "col_18_str", + "valueType": "str" + }, + { + "label": "col_19_fixedstr16", + "valueType": "str" + }, + { + "label": "col_20_uint8", + "valueType": "ui8" + }, + { + "label": "col_21_int8", + "valueType": "si8" + }, + { + "label": "col_22_uint32", + "valueType": "ui32" + }, + { + "label": "col_23_int32", + "valueType": "si32" + }, + { + "label": "col_24_uint64", + "valueType": "ui64" + }, + { + "label": "col_25_int64", + "valueType": "si64" + }, + { + "label": "col_26_float32", + "valueType": "f32" + }, + { + "label": "col_27_float64", + "valueType": "f64" + }, + { + "label": "col_28_str", + "valueType": "str" + }, + { + "label": "col_29_fixedstr16", + "valueType": "str" + }, + { + "label": "col_30_uint8", + "valueType": "ui8" + }, + { + "label": "col_31_int8", + "valueType": "si8" + }, + { + "label": "col_32_uint32", + "valueType": "ui32" + }, + { + "label": "col_33_int32", + "valueType": "si32" + }, + { + "label": "col_34_uint64", + "valueType": "ui64" + }, + { + "label": "col_35_int64", + "valueType": "si64" + }, + { + "label": "col_36_float32", + "valueType": "f32" + }, + { + "label": "col_37_float64", + "valueType": "f64" + }, + { + "label": "col_38_str", + "valueType": "str" + }, + { + "label": "col_39_fixedstr16", + "valueType": "str" + }, + { + "label": "col_40_uint8", + "valueType": "ui8" + }, + { + "label": "col_41_int8", + "valueType": "si8" + }, + { + "label": "col_42_uint32", + "valueType": "ui32" + }, + { + "label": "col_43_int32", + "valueType": "si32" + }, + { + "label": "col_44_uint64", + "valueType": "ui64" + }, + { + "label": "col_45_int64", + "valueType": "si64" + }, + { + "label": "col_46_float32", + "valueType": "f32" + }, + { + "label": "col_47_float64", + "valueType": "f64" + }, + { + "label": "col_48_str", + "valueType": "str" + }, + { + "label": "col_49_fixedstr16", + "valueType": "str" + }, + { + "label": "col_50_uint8", + "valueType": "ui8" + }, + { + "label": "col_51_int8", + "valueType": "si8" + }, + { + "label": "col_52_uint32", + "valueType": "ui32" + }, + { + "label": "col_53_int32", + "valueType": "si32" + }, + { + "label": "col_54_uint64", + "valueType": "ui64" + }, + { + "label": "col_55_int64", + "valueType": "si64" + }, + { + "label": "col_56_float32", + "valueType": "f32" + }, + { + "label": "col_57_float64", + "valueType": "f64" + }, + { + "label": "col_58_str", + "valueType": "str" + }, + { + "label": "col_59_fixedstr16", + "valueType": "str" + }, + { + "label": "col_60_uint8", + "valueType": "ui8" + }, + { + "label": "col_61_int8", + "valueType": "si8" + }, + { + "label": "col_62_uint32", + "valueType": "ui32" + }, + { + "label": "col_63_int32", + "valueType": "si32" + }, + { + "label": "col_64_uint64", + "valueType": "ui64" + }, + { + "label": "col_65_int64", + "valueType": "si64" + }, + { + "label": "col_66_float32", + "valueType": "f32" + }, + { + "label": "col_67_float64", + "valueType": "f64" + }, + { + "label": "col_68_str", + "valueType": "str" + }, + { + "label": "col_69_fixedstr16", + "valueType": "str" + }, + { + "label": "col_70_uint8", + "valueType": "ui8" + }, + { + "label": "col_71_int8", + "valueType": "si8" + }, + { + "label": "col_72_uint32", + "valueType": "ui32" + }, + { + "label": "col_73_int32", + "valueType": "si32" + }, + { + "label": "col_74_uint64", + "valueType": "ui64" + }, + { + "label": "col_75_int64", + "valueType": "si64" + }, + { + "label": "col_76_float32", + "valueType": "f32" + }, + { + "label": "col_77_float64", + "valueType": "f64" + }, + { + "label": "col_78_str", + "valueType": "str" + }, + { + "label": "col_79_fixedstr16", + "valueType": "str" + }, + { + "label": "col_80_uint8", + "valueType": "ui8" + }, + { + "label": "col_81_int8", + "valueType": "si8" + }, + { + "label": "col_82_uint32", + "valueType": "ui32" + }, + { + "label": "col_83_int32", + "valueType": "si32" + }, + { + "label": "col_84_uint64", + "valueType": "ui64" + }, + { + "label": "col_85_int64", + "valueType": "si64" + }, + { + "label": "col_86_float32", + "valueType": "f32" + }, + { + "label": "col_87_float64", + "valueType": "f64" + }, + { + "label": "col_88_str", + "valueType": "str" + }, + { + "label": "col_89_fixedstr16", + "valueType": "str" + }, + { + "label": "col_90_uint8", + "valueType": "ui8" + }, + { + "label": "col_91_int8", + "valueType": "si8" + }, + { + "label": "col_92_uint32", + "valueType": "ui32" + }, + { + "label": "col_93_int32", + "valueType": "si32" + }, + { + "label": "col_94_uint64", + "valueType": "ui64" + }, + { + "label": "col_95_int64", + "valueType": "si64" + }, + { + "label": "col_96_float32", + "valueType": "f32" + }, + { + "label": "col_97_float64", + "valueType": "f64" + }, + { + "label": "col_98_str", + "valueType": "str" + }, + { + "label": "col_99_fixedstr16", + "valueType": "str" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_5000000r_100c_NUMBER.csv.meta b/evaluation/data/frame_5000000r_100c_NUMBER.csv.meta new file mode 100644 index 000000000..360efd4c6 --- /dev/null +++ b/evaluation/data/frame_5000000r_100c_NUMBER.csv.meta @@ -0,0 +1,406 @@ +{ + "numRows": 5000000, + "numCols": 100, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_uint8", + "valueType": "ui8" + }, + { + "label": "col_9_int8", + "valueType": "si8" + }, + { + "label": "col_10_uint32", + "valueType": "ui32" + }, + { + "label": "col_11_int32", + "valueType": "si32" + }, + { + "label": "col_12_uint64", + "valueType": "ui64" + }, + { + "label": "col_13_int64", + "valueType": "si64" + }, + { + "label": "col_14_float32", + "valueType": "f32" + }, + { + "label": "col_15_float64", + "valueType": "f64" + }, + { + "label": "col_16_uint8", + "valueType": "ui8" + }, + { + "label": "col_17_int8", + "valueType": "si8" + }, + { + "label": "col_18_uint32", + "valueType": "ui32" + }, + { + "label": "col_19_int32", + "valueType": "si32" + }, + { + "label": "col_20_uint64", + "valueType": "ui64" + }, + { + "label": "col_21_int64", + "valueType": "si64" + }, + { + "label": "col_22_float32", + "valueType": "f32" + }, + { + "label": "col_23_float64", + "valueType": "f64" + }, + { + "label": "col_24_uint8", + "valueType": "ui8" + }, + { + "label": "col_25_int8", + "valueType": "si8" + }, + { + "label": "col_26_uint32", + "valueType": "ui32" + }, + { + "label": "col_27_int32", + "valueType": "si32" + }, + { + "label": "col_28_uint64", + "valueType": "ui64" + }, + { + "label": "col_29_int64", + "valueType": "si64" + }, + { + "label": "col_30_float32", + "valueType": "f32" + }, + { + "label": "col_31_float64", + "valueType": "f64" + }, + { + "label": "col_32_uint8", + "valueType": "ui8" + }, + { + "label": "col_33_int8", + "valueType": "si8" + }, + { + "label": "col_34_uint32", + "valueType": "ui32" + }, + { + "label": "col_35_int32", + "valueType": "si32" + }, + { + "label": "col_36_uint64", + "valueType": "ui64" + }, + { + "label": "col_37_int64", + "valueType": "si64" + }, + { + "label": "col_38_float32", + "valueType": "f32" + }, + { + "label": "col_39_float64", + "valueType": "f64" + }, + { + "label": "col_40_uint8", + "valueType": "ui8" + }, + { + "label": "col_41_int8", + "valueType": "si8" + }, + { + "label": "col_42_uint32", + "valueType": "ui32" + }, + { + "label": "col_43_int32", + "valueType": "si32" + }, + { + "label": "col_44_uint64", + "valueType": "ui64" + }, + { + "label": "col_45_int64", + "valueType": "si64" + }, + { + "label": "col_46_float32", + "valueType": "f32" + }, + { + "label": "col_47_float64", + "valueType": "f64" + }, + { + "label": "col_48_uint8", + "valueType": "ui8" + }, + { + "label": "col_49_int8", + "valueType": "si8" + }, + { + "label": "col_50_uint32", + "valueType": "ui32" + }, + { + "label": "col_51_int32", + "valueType": "si32" + }, + { + "label": "col_52_uint64", + "valueType": "ui64" + }, + { + "label": "col_53_int64", + "valueType": "si64" + }, + { + "label": "col_54_float32", + "valueType": "f32" + }, + { + "label": "col_55_float64", + "valueType": "f64" + }, + { + "label": "col_56_uint8", + "valueType": "ui8" + }, + { + "label": "col_57_int8", + "valueType": "si8" + }, + { + "label": "col_58_uint32", + "valueType": "ui32" + }, + { + "label": "col_59_int32", + "valueType": "si32" + }, + { + "label": "col_60_uint64", + "valueType": "ui64" + }, + { + "label": "col_61_int64", + "valueType": "si64" + }, + { + "label": "col_62_float32", + "valueType": "f32" + }, + { + "label": "col_63_float64", + "valueType": "f64" + }, + { + "label": "col_64_uint8", + "valueType": "ui8" + }, + { + "label": "col_65_int8", + "valueType": "si8" + }, + { + "label": "col_66_uint32", + "valueType": "ui32" + }, + { + "label": "col_67_int32", + "valueType": "si32" + }, + { + "label": "col_68_uint64", + "valueType": "ui64" + }, + { + "label": "col_69_int64", + "valueType": "si64" + }, + { + "label": "col_70_float32", + "valueType": "f32" + }, + { + "label": "col_71_float64", + "valueType": "f64" + }, + { + "label": "col_72_uint8", + "valueType": "ui8" + }, + { + "label": "col_73_int8", + "valueType": "si8" + }, + { + "label": "col_74_uint32", + "valueType": "ui32" + }, + { + "label": "col_75_int32", + "valueType": "si32" + }, + { + "label": "col_76_uint64", + "valueType": "ui64" + }, + { + "label": "col_77_int64", + "valueType": "si64" + }, + { + "label": "col_78_float32", + "valueType": "f32" + }, + { + "label": "col_79_float64", + "valueType": "f64" + }, + { + "label": "col_80_uint8", + "valueType": "ui8" + }, + { + "label": "col_81_int8", + "valueType": "si8" + }, + { + "label": "col_82_uint32", + "valueType": "ui32" + }, + { + "label": "col_83_int32", + "valueType": "si32" + }, + { + "label": "col_84_uint64", + "valueType": "ui64" + }, + { + "label": "col_85_int64", + "valueType": "si64" + }, + { + "label": "col_86_float32", + "valueType": "f32" + }, + { + "label": "col_87_float64", + "valueType": "f64" + }, + { + "label": "col_88_uint8", + "valueType": "ui8" + }, + { + "label": "col_89_int8", + "valueType": "si8" + }, + { + "label": "col_90_uint32", + "valueType": "ui32" + }, + { + "label": "col_91_int32", + "valueType": "si32" + }, + { + "label": "col_92_uint64", + "valueType": "ui64" + }, + { + "label": "col_93_int64", + "valueType": "si64" + }, + { + "label": "col_94_float32", + "valueType": "f32" + }, + { + "label": "col_95_float64", + "valueType": "f64" + }, + { + "label": "col_96_uint8", + "valueType": "ui8" + }, + { + "label": "col_97_int8", + "valueType": "si8" + }, + { + "label": "col_98_uint32", + "valueType": "ui32" + }, + { + "label": "col_99_int32", + "valueType": "si32" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_500000r_50c_NUMBER.csv.meta b/evaluation/data/frame_500000r_50c_NUMBER.csv.meta new file mode 100644 index 000000000..29a14e0fd --- /dev/null +++ b/evaluation/data/frame_500000r_50c_NUMBER.csv.meta @@ -0,0 +1,206 @@ +{ + "numRows": 500000, + "numCols": 50, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_uint8", + "valueType": "ui8" + }, + { + "label": "col_9_int8", + "valueType": "si8" + }, + { + "label": "col_10_uint32", + "valueType": "ui32" + }, + { + "label": "col_11_int32", + "valueType": "si32" + }, + { + "label": "col_12_uint64", + "valueType": "ui64" + }, + { + "label": "col_13_int64", + "valueType": "si64" + }, + { + "label": "col_14_float32", + "valueType": "f32" + }, + { + "label": "col_15_float64", + "valueType": "f64" + }, + { + "label": "col_16_uint8", + "valueType": "ui8" + }, + { + "label": "col_17_int8", + "valueType": "si8" + }, + { + "label": "col_18_uint32", + "valueType": "ui32" + }, + { + "label": "col_19_int32", + "valueType": "si32" + }, + { + "label": "col_20_uint64", + "valueType": "ui64" + }, + { + "label": "col_21_int64", + "valueType": "si64" + }, + { + "label": "col_22_float32", + "valueType": "f32" + }, + { + "label": "col_23_float64", + "valueType": "f64" + }, + { + "label": "col_24_uint8", + "valueType": "ui8" + }, + { + "label": "col_25_int8", + "valueType": "si8" + }, + { + "label": "col_26_uint32", + "valueType": "ui32" + }, + { + "label": "col_27_int32", + "valueType": "si32" + }, + { + "label": "col_28_uint64", + "valueType": "ui64" + }, + { + "label": "col_29_int64", + "valueType": "si64" + }, + { + "label": "col_30_float32", + "valueType": "f32" + }, + { + "label": "col_31_float64", + "valueType": "f64" + }, + { + "label": "col_32_uint8", + "valueType": "ui8" + }, + { + "label": "col_33_int8", + "valueType": "si8" + }, + { + "label": "col_34_uint32", + "valueType": "ui32" + }, + { + "label": "col_35_int32", + "valueType": "si32" + }, + { + "label": "col_36_uint64", + "valueType": "ui64" + }, + { + "label": "col_37_int64", + "valueType": "si64" + }, + { + "label": "col_38_float32", + "valueType": "f32" + }, + { + "label": "col_39_float64", + "valueType": "f64" + }, + { + "label": "col_40_uint8", + "valueType": "ui8" + }, + { + "label": "col_41_int8", + "valueType": "si8" + }, + { + "label": "col_42_uint32", + "valueType": "ui32" + }, + { + "label": "col_43_int32", + "valueType": "si32" + }, + { + "label": "col_44_uint64", + "valueType": "ui64" + }, + { + "label": "col_45_int64", + "valueType": "si64" + }, + { + "label": "col_46_float32", + "valueType": "f32" + }, + { + "label": "col_47_float64", + "valueType": "f64" + }, + { + "label": "col_48_uint8", + "valueType": "ui8" + }, + { + "label": "col_49_int8", + "valueType": "si8" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_50000r_100c_MIXED.csv.meta b/evaluation/data/frame_50000r_100c_MIXED.csv.meta new file mode 100644 index 000000000..0f8756d28 --- /dev/null +++ b/evaluation/data/frame_50000r_100c_MIXED.csv.meta @@ -0,0 +1,406 @@ +{ + "numRows": 50000, + "numCols": 100, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_str", + "valueType": "str" + }, + { + "label": "col_9_fixedstr16", + "valueType": "str" + }, + { + "label": "col_10_uint8", + "valueType": "ui8" + }, + { + "label": "col_11_int8", + "valueType": "si8" + }, + { + "label": "col_12_uint32", + "valueType": "ui32" + }, + { + "label": "col_13_int32", + "valueType": "si32" + }, + { + "label": "col_14_uint64", + "valueType": "ui64" + }, + { + "label": "col_15_int64", + "valueType": "si64" + }, + { + "label": "col_16_float32", + "valueType": "f32" + }, + { + "label": "col_17_float64", + "valueType": "f64" + }, + { + "label": "col_18_str", + "valueType": "str" + }, + { + "label": "col_19_fixedstr16", + "valueType": "str" + }, + { + "label": "col_20_uint8", + "valueType": "ui8" + }, + { + "label": "col_21_int8", + "valueType": "si8" + }, + { + "label": "col_22_uint32", + "valueType": "ui32" + }, + { + "label": "col_23_int32", + "valueType": "si32" + }, + { + "label": "col_24_uint64", + "valueType": "ui64" + }, + { + "label": "col_25_int64", + "valueType": "si64" + }, + { + "label": "col_26_float32", + "valueType": "f32" + }, + { + "label": "col_27_float64", + "valueType": "f64" + }, + { + "label": "col_28_str", + "valueType": "str" + }, + { + "label": "col_29_fixedstr16", + "valueType": "str" + }, + { + "label": "col_30_uint8", + "valueType": "ui8" + }, + { + "label": "col_31_int8", + "valueType": "si8" + }, + { + "label": "col_32_uint32", + "valueType": "ui32" + }, + { + "label": "col_33_int32", + "valueType": "si32" + }, + { + "label": "col_34_uint64", + "valueType": "ui64" + }, + { + "label": "col_35_int64", + "valueType": "si64" + }, + { + "label": "col_36_float32", + "valueType": "f32" + }, + { + "label": "col_37_float64", + "valueType": "f64" + }, + { + "label": "col_38_str", + "valueType": "str" + }, + { + "label": "col_39_fixedstr16", + "valueType": "str" + }, + { + "label": "col_40_uint8", + "valueType": "ui8" + }, + { + "label": "col_41_int8", + "valueType": "si8" + }, + { + "label": "col_42_uint32", + "valueType": "ui32" + }, + { + "label": "col_43_int32", + "valueType": "si32" + }, + { + "label": "col_44_uint64", + "valueType": "ui64" + }, + { + "label": "col_45_int64", + "valueType": "si64" + }, + { + "label": "col_46_float32", + "valueType": "f32" + }, + { + "label": "col_47_float64", + "valueType": "f64" + }, + { + "label": "col_48_str", + "valueType": "str" + }, + { + "label": "col_49_fixedstr16", + "valueType": "str" + }, + { + "label": "col_50_uint8", + "valueType": "ui8" + }, + { + "label": "col_51_int8", + "valueType": "si8" + }, + { + "label": "col_52_uint32", + "valueType": "ui32" + }, + { + "label": "col_53_int32", + "valueType": "si32" + }, + { + "label": "col_54_uint64", + "valueType": "ui64" + }, + { + "label": "col_55_int64", + "valueType": "si64" + }, + { + "label": "col_56_float32", + "valueType": "f32" + }, + { + "label": "col_57_float64", + "valueType": "f64" + }, + { + "label": "col_58_str", + "valueType": "str" + }, + { + "label": "col_59_fixedstr16", + "valueType": "str" + }, + { + "label": "col_60_uint8", + "valueType": "ui8" + }, + { + "label": "col_61_int8", + "valueType": "si8" + }, + { + "label": "col_62_uint32", + "valueType": "ui32" + }, + { + "label": "col_63_int32", + "valueType": "si32" + }, + { + "label": "col_64_uint64", + "valueType": "ui64" + }, + { + "label": "col_65_int64", + "valueType": "si64" + }, + { + "label": "col_66_float32", + "valueType": "f32" + }, + { + "label": "col_67_float64", + "valueType": "f64" + }, + { + "label": "col_68_str", + "valueType": "str" + }, + { + "label": "col_69_fixedstr16", + "valueType": "str" + }, + { + "label": "col_70_uint8", + "valueType": "ui8" + }, + { + "label": "col_71_int8", + "valueType": "si8" + }, + { + "label": "col_72_uint32", + "valueType": "ui32" + }, + { + "label": "col_73_int32", + "valueType": "si32" + }, + { + "label": "col_74_uint64", + "valueType": "ui64" + }, + { + "label": "col_75_int64", + "valueType": "si64" + }, + { + "label": "col_76_float32", + "valueType": "f32" + }, + { + "label": "col_77_float64", + "valueType": "f64" + }, + { + "label": "col_78_str", + "valueType": "str" + }, + { + "label": "col_79_fixedstr16", + "valueType": "str" + }, + { + "label": "col_80_uint8", + "valueType": "ui8" + }, + { + "label": "col_81_int8", + "valueType": "si8" + }, + { + "label": "col_82_uint32", + "valueType": "ui32" + }, + { + "label": "col_83_int32", + "valueType": "si32" + }, + { + "label": "col_84_uint64", + "valueType": "ui64" + }, + { + "label": "col_85_int64", + "valueType": "si64" + }, + { + "label": "col_86_float32", + "valueType": "f32" + }, + { + "label": "col_87_float64", + "valueType": "f64" + }, + { + "label": "col_88_str", + "valueType": "str" + }, + { + "label": "col_89_fixedstr16", + "valueType": "str" + }, + { + "label": "col_90_uint8", + "valueType": "ui8" + }, + { + "label": "col_91_int8", + "valueType": "si8" + }, + { + "label": "col_92_uint32", + "valueType": "ui32" + }, + { + "label": "col_93_int32", + "valueType": "si32" + }, + { + "label": "col_94_uint64", + "valueType": "ui64" + }, + { + "label": "col_95_int64", + "valueType": "si64" + }, + { + "label": "col_96_float32", + "valueType": "f32" + }, + { + "label": "col_97_float64", + "valueType": "f64" + }, + { + "label": "col_98_str", + "valueType": "str" + }, + { + "label": "col_99_fixedstr16", + "valueType": "str" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/frame_50000r_100c_NUMBER.csv.meta b/evaluation/data/frame_50000r_100c_NUMBER.csv.meta new file mode 100644 index 000000000..b2b890d17 --- /dev/null +++ b/evaluation/data/frame_50000r_100c_NUMBER.csv.meta @@ -0,0 +1,406 @@ +{ + "numRows": 50000, + "numCols": 100, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_uint8", + "valueType": "ui8" + }, + { + "label": "col_9_int8", + "valueType": "si8" + }, + { + "label": "col_10_uint32", + "valueType": "ui32" + }, + { + "label": "col_11_int32", + "valueType": "si32" + }, + { + "label": "col_12_uint64", + "valueType": "ui64" + }, + { + "label": "col_13_int64", + "valueType": "si64" + }, + { + "label": "col_14_float32", + "valueType": "f32" + }, + { + "label": "col_15_float64", + "valueType": "f64" + }, + { + "label": "col_16_uint8", + "valueType": "ui8" + }, + { + "label": "col_17_int8", + "valueType": "si8" + }, + { + "label": "col_18_uint32", + "valueType": "ui32" + }, + { + "label": "col_19_int32", + "valueType": "si32" + }, + { + "label": "col_20_uint64", + "valueType": "ui64" + }, + { + "label": "col_21_int64", + "valueType": "si64" + }, + { + "label": "col_22_float32", + "valueType": "f32" + }, + { + "label": "col_23_float64", + "valueType": "f64" + }, + { + "label": "col_24_uint8", + "valueType": "ui8" + }, + { + "label": "col_25_int8", + "valueType": "si8" + }, + { + "label": "col_26_uint32", + "valueType": "ui32" + }, + { + "label": "col_27_int32", + "valueType": "si32" + }, + { + "label": "col_28_uint64", + "valueType": "ui64" + }, + { + "label": "col_29_int64", + "valueType": "si64" + }, + { + "label": "col_30_float32", + "valueType": "f32" + }, + { + "label": "col_31_float64", + "valueType": "f64" + }, + { + "label": "col_32_uint8", + "valueType": "ui8" + }, + { + "label": "col_33_int8", + "valueType": "si8" + }, + { + "label": "col_34_uint32", + "valueType": "ui32" + }, + { + "label": "col_35_int32", + "valueType": "si32" + }, + { + "label": "col_36_uint64", + "valueType": "ui64" + }, + { + "label": "col_37_int64", + "valueType": "si64" + }, + { + "label": "col_38_float32", + "valueType": "f32" + }, + { + "label": "col_39_float64", + "valueType": "f64" + }, + { + "label": "col_40_uint8", + "valueType": "ui8" + }, + { + "label": "col_41_int8", + "valueType": "si8" + }, + { + "label": "col_42_uint32", + "valueType": "ui32" + }, + { + "label": "col_43_int32", + "valueType": "si32" + }, + { + "label": "col_44_uint64", + "valueType": "ui64" + }, + { + "label": "col_45_int64", + "valueType": "si64" + }, + { + "label": "col_46_float32", + "valueType": "f32" + }, + { + "label": "col_47_float64", + "valueType": "f64" + }, + { + "label": "col_48_uint8", + "valueType": "ui8" + }, + { + "label": "col_49_int8", + "valueType": "si8" + }, + { + "label": "col_50_uint32", + "valueType": "ui32" + }, + { + "label": "col_51_int32", + "valueType": "si32" + }, + { + "label": "col_52_uint64", + "valueType": "ui64" + }, + { + "label": "col_53_int64", + "valueType": "si64" + }, + { + "label": "col_54_float32", + "valueType": "f32" + }, + { + "label": "col_55_float64", + "valueType": "f64" + }, + { + "label": "col_56_uint8", + "valueType": "ui8" + }, + { + "label": "col_57_int8", + "valueType": "si8" + }, + { + "label": "col_58_uint32", + "valueType": "ui32" + }, + { + "label": "col_59_int32", + "valueType": "si32" + }, + { + "label": "col_60_uint64", + "valueType": "ui64" + }, + { + "label": "col_61_int64", + "valueType": "si64" + }, + { + "label": "col_62_float32", + "valueType": "f32" + }, + { + "label": "col_63_float64", + "valueType": "f64" + }, + { + "label": "col_64_uint8", + "valueType": "ui8" + }, + { + "label": "col_65_int8", + "valueType": "si8" + }, + { + "label": "col_66_uint32", + "valueType": "ui32" + }, + { + "label": "col_67_int32", + "valueType": "si32" + }, + { + "label": "col_68_uint64", + "valueType": "ui64" + }, + { + "label": "col_69_int64", + "valueType": "si64" + }, + { + "label": "col_70_float32", + "valueType": "f32" + }, + { + "label": "col_71_float64", + "valueType": "f64" + }, + { + "label": "col_72_uint8", + "valueType": "ui8" + }, + { + "label": "col_73_int8", + "valueType": "si8" + }, + { + "label": "col_74_uint32", + "valueType": "ui32" + }, + { + "label": "col_75_int32", + "valueType": "si32" + }, + { + "label": "col_76_uint64", + "valueType": "ui64" + }, + { + "label": "col_77_int64", + "valueType": "si64" + }, + { + "label": "col_78_float32", + "valueType": "f32" + }, + { + "label": "col_79_float64", + "valueType": "f64" + }, + { + "label": "col_80_uint8", + "valueType": "ui8" + }, + { + "label": "col_81_int8", + "valueType": "si8" + }, + { + "label": "col_82_uint32", + "valueType": "ui32" + }, + { + "label": "col_83_int32", + "valueType": "si32" + }, + { + "label": "col_84_uint64", + "valueType": "ui64" + }, + { + "label": "col_85_int64", + "valueType": "si64" + }, + { + "label": "col_86_float32", + "valueType": "f32" + }, + { + "label": "col_87_float64", + "valueType": "f64" + }, + { + "label": "col_88_uint8", + "valueType": "ui8" + }, + { + "label": "col_89_int8", + "valueType": "si8" + }, + { + "label": "col_90_uint32", + "valueType": "ui32" + }, + { + "label": "col_91_int32", + "valueType": "si32" + }, + { + "label": "col_92_uint64", + "valueType": "ui64" + }, + { + "label": "col_93_int64", + "valueType": "si64" + }, + { + "label": "col_94_float32", + "valueType": "f32" + }, + { + "label": "col_95_float64", + "valueType": "f64" + }, + { + "label": "col_96_uint8", + "valueType": "ui8" + }, + { + "label": "col_97_int8", + "valueType": "si8" + }, + { + "label": "col_98_uint32", + "valueType": "ui32" + }, + { + "label": "col_99_int32", + "valueType": "si32" + } + ] +} \ No newline at end of file diff --git a/evaluation/data/matrix_100000r_20c_FLOAT.csv.meta b/evaluation/data/matrix_100000r_20c_FLOAT.csv.meta new file mode 100644 index 000000000..df35f1f0d --- /dev/null +++ b/evaluation/data/matrix_100000r_20c_FLOAT.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 100000, + "numCols": 20, + "valueType": "f64" +} \ No newline at end of file diff --git a/evaluation/data/matrix_100000r_20c_STR.csv.meta b/evaluation/data/matrix_100000r_20c_STR.csv.meta new file mode 100644 index 000000000..6a5935ec6 --- /dev/null +++ b/evaluation/data/matrix_100000r_20c_STR.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 100000, + "numCols": 20, + "valueType": "str" +} \ No newline at end of file diff --git a/evaluation/data/matrix_10000r_20c_FLOAT.csv.meta b/evaluation/data/matrix_10000r_20c_FLOAT.csv.meta new file mode 100644 index 000000000..cb7114965 --- /dev/null +++ b/evaluation/data/matrix_10000r_20c_FLOAT.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 10000, + "numCols": 20, + "valueType": "f64" +} \ No newline at end of file diff --git a/evaluation/data/matrix_10000r_20c_STR.csv.meta b/evaluation/data/matrix_10000r_20c_STR.csv.meta new file mode 100644 index 000000000..745c8dc18 --- /dev/null +++ b/evaluation/data/matrix_10000r_20c_STR.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 10000, + "numCols": 20, + "valueType": "str" +} \ No newline at end of file diff --git a/evaluation/data/matrix_1000r_10c_FLOAT.csv.meta b/evaluation/data/matrix_1000r_10c_FLOAT.csv.meta new file mode 100644 index 000000000..7e61fbbab --- /dev/null +++ b/evaluation/data/matrix_1000r_10c_FLOAT.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 1000, + "numCols": 10, + "valueType": "f64" +} \ No newline at end of file diff --git a/evaluation/data/matrix_1000r_10c_STR.csv.meta b/evaluation/data/matrix_1000r_10c_STR.csv.meta new file mode 100644 index 000000000..a979de561 --- /dev/null +++ b/evaluation/data/matrix_1000r_10c_STR.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 1000, + "numCols": 10, + "valueType": "str" +} \ No newline at end of file diff --git a/evaluation/data/matrix_5000000r_100c_STR.csv.meta b/evaluation/data/matrix_5000000r_100c_STR.csv.meta new file mode 100644 index 000000000..c3e5851eb --- /dev/null +++ b/evaluation/data/matrix_5000000r_100c_STR.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 5000000, + "numCols": 100, + "valueType": "str" +} \ No newline at end of file diff --git a/evaluation/data/matrix_500000r_50c_FLOAT.csv.meta b/evaluation/data/matrix_500000r_50c_FLOAT.csv.meta new file mode 100644 index 000000000..882f582cd --- /dev/null +++ b/evaluation/data/matrix_500000r_50c_FLOAT.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 500000, + "numCols": 50, + "valueType": "f64" +} \ No newline at end of file diff --git a/evaluation/data/matrix_500000r_50c_REP.csv.meta b/evaluation/data/matrix_500000r_50c_REP.csv.meta new file mode 100644 index 000000000..dafef8f73 --- /dev/null +++ b/evaluation/data/matrix_500000r_50c_REP.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 500000, + "numCols": 50, + "valueType": "si64" +} \ No newline at end of file diff --git a/evaluation/data/matrix_500000r_50c_STR.csv.meta b/evaluation/data/matrix_500000r_50c_STR.csv.meta new file mode 100644 index 000000000..67dcc2f1a --- /dev/null +++ b/evaluation/data/matrix_500000r_50c_STR.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 500000, + "numCols": 50, + "valueType": "str" +} \ No newline at end of file diff --git a/evaluation/data/matrix_50000r_100c_FLOAT.csv.meta b/evaluation/data/matrix_50000r_100c_FLOAT.csv.meta new file mode 100644 index 000000000..128b1d6cc --- /dev/null +++ b/evaluation/data/matrix_50000r_100c_FLOAT.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 50000, + "numCols": 100, + "valueType": "f64" +} \ No newline at end of file diff --git a/evaluation/data/matrix_50000r_100c_STR.csv.meta b/evaluation/data/matrix_50000r_100c_STR.csv.meta new file mode 100644 index 000000000..1097504ef --- /dev/null +++ b/evaluation/data/matrix_50000r_100c_STR.csv.meta @@ -0,0 +1,5 @@ +{ + "numRows": 50000, + "numCols": 100, + "valueType": "str" +} \ No newline at end of file diff --git a/evaluation/data_1000r_10c_NUMBER.csv b/evaluation/data_1000r_10c_NUMBER.csv new file mode 100644 index 000000000..9f1d5b75f --- /dev/null +++ b/evaluation/data_1000r_10c_NUMBER.csv @@ -0,0 +1,1000 @@ +200,82,5235,-534,573,-8479,0.8882244,0.7346585427037533,225,-97 +14,-89,4847,557,246,6845,0.19743992,0.6735912853501502,227,127 +58,-57,7610,935,9771,2069,0.9923728,0.19198279309439947,184,-124 +164,14,3298,247,2108,-1827,0.8468459,0.920403937736666,194,-82 +39,-14,4263,-477,4931,4931,0.7211194,0.025854190986898562,100,7 +238,100,8269,156,3439,-707,0.43660992,0.023042209672241798,182,61 +165,46,492,-42,9425,6696,0.24557444,0.9956600475300597,249,45 +142,-94,3168,62,5879,8963,0.68404937,0.015039713364382812,145,73 +116,-91,3094,413,3495,-5157,0.5905226,0.9775351024920214,221,47 +226,-38,2707,830,2378,506,0.6258205,0.7946534221058357,160,-118 +87,0,9491,-963,7743,3286,0.5817841,0.2999177599984396,14,96 +159,76,8588,-579,7084,-982,0.29716742,0.5569005434696782,94,-101 +195,20,6463,-671,4131,-2017,0.9177281,0.7633677547680602,7,-45 +203,-23,3867,918,4753,-2021,0.4862539,0.6455015215368652,215,-111 +234,-16,775,719,6496,1002,0.5156733,0.9911050385316791,75,99 +104,41,1328,-887,8928,464,0.089373894,0.48537937522467445,37,-71 +194,-5,4437,903,9005,-3204,0.24475451,0.9180450732065761,29,90 +12,-101,793,-34,5413,-7864,0.9654111,0.486552804538532,25,100 +196,-17,2643,854,4388,5501,0.8465457,0.9794504920948095,104,-45 +240,84,4573,-602,5691,4374,0.023441432,0.6615626874692132,113,9 +92,97,9251,277,5487,-991,0.68377,0.013169975692080782,243,-91 +41,6,996,271,4111,9817,0.13684389,0.6488269619095558,96,54 +6,-54,6645,19,3101,-4676,0.09855881,0.26489017468000686,179,68 +224,-81,1941,-587,466,7728,0.087096155,0.23597325662373347,57,34 +38,-83,1731,-855,4829,9631,0.33312336,0.8576492305128813,255,-63 +176,50,8767,979,6486,2933,0.70364803,0.39424879888061903,207,-41 +158,-117,7338,-264,4555,5405,0.35948312,0.4725866854763098,190,69 +254,70,5744,673,3118,-9347,0.68917346,0.4577109296587122,22,-83 +21,-79,7887,-420,4745,-1002,0.63042235,0.8295484057717657,231,-121 +86,10,8903,-421,5972,9284,0.36195678,0.4071893238152293,45,3 +69,63,3565,-41,1256,-47,0.968588,0.6743055210639889,222,104 +87,-88,2487,-218,3290,7466,0.51084626,0.19848637317046525,243,72 +219,-17,8220,-382,4938,-8647,0.7073791,0.3829911823783134,218,-25 +165,-124,9995,-247,2156,4207,0.8028039,0.03732850755685124,94,104 +216,30,4503,-182,5686,2310,0.049674504,0.09413331774842126,143,17 +156,14,5135,593,6984,-4088,0.077437155,0.21644496089514031,69,113 +54,-95,4408,-436,5678,8607,0.339864,0.4636714101771321,44,16 +164,-78,9170,-842,1316,-2892,0.5037034,0.9859831892903401,88,61 +140,-46,7515,-393,8329,-9087,0.90992206,0.026358699224931614,174,28 +10,112,4118,487,5859,3871,0.3787963,0.09134155267831168,159,-4 +4,81,9571,754,9389,1277,0.24959233,0.30560776800350575,227,109 +201,-101,9532,311,4038,9713,0.55087686,0.641970054801359,210,45 +46,101,6951,466,8849,7589,0.68477374,0.9900918441315846,97,-96 +76,28,5987,530,4687,-452,0.74298584,0.31102881758623113,182,114 +245,-62,9313,488,9470,-8414,0.3307072,0.7929368145453276,190,-4 +55,-58,8169,-643,3640,-6261,0.38275307,0.22436226090609013,28,126 +10,-76,9917,-132,5825,2033,0.4643399,0.38745970584212863,137,115 +117,-33,6235,-924,9103,5503,0.93990386,0.8420573044384752,238,-99 +113,-104,950,251,8858,-9824,0.75145394,0.21181326999929595,242,-73 +78,48,694,-885,1946,1187,0.9283907,0.5967933297179724,176,-4 +16,-100,9015,665,1534,8400,0.090411514,0.736744241642614,196,27 +218,-78,6139,-615,7058,3539,0.18889737,0.6801978736439255,78,85 +120,-7,9455,-405,36,4850,0.7179572,0.3519962559095222,7,-106 +74,-117,9464,186,5243,-6831,0.2584546,0.0750605138403454,166,-18 +255,-28,4873,867,3586,-5056,0.19199526,0.007582188901917863,107,-61 +245,-68,2931,641,2755,5874,0.82171315,0.8791786419734651,158,-2 +97,47,9885,-737,8883,8735,0.40505302,0.8532725906721419,43,-95 +57,105,7421,-228,1760,8709,0.37999892,0.42826219188613013,9,115 +164,14,3380,-989,7321,-932,0.09167332,0.6290212911829042,56,95 +31,-16,758,223,266,-551,0.656978,0.5383023362160505,95,-93 +43,-1,2709,-961,3165,-5589,0.5360074,0.9088390836212301,132,-97 +152,46,7894,180,1232,1541,0.59899217,0.6531898738767308,25,-109 +61,-74,7786,-99,3306,-8890,0.20293862,0.301735644907545,175,60 +76,64,2711,-541,7424,-8856,0.5354896,0.8563877402370965,207,42 +37,-63,2335,683,3577,-927,0.43647292,0.8799206006598328,29,13 +52,26,2954,-590,3883,-4393,0.46022096,0.2724009945421394,230,-61 +173,5,462,581,2182,50,0.52962846,0.10674421087566699,162,-56 +38,110,3947,943,2801,-4499,0.99055195,0.5737585392316543,143,-60 +149,-61,4153,-824,3895,-8573,0.2592369,0.753601900003261,177,-36 +97,-64,6392,317,9252,7311,0.94491875,0.17096400877982976,175,-31 +176,-103,8868,953,3707,-2650,0.10889884,0.6173483733004063,194,117 +54,-46,1264,-524,1581,3886,0.3349101,0.9296149046316423,206,124 +220,-76,1147,-133,6125,-3238,0.5072835,0.15108896149591444,255,103 +248,82,6066,638,9329,-8919,0.32043308,0.9801165050494032,152,79 +35,-82,5791,-670,2795,-9416,0.75315386,0.43160664502418766,102,-123 +31,107,8967,-197,2263,-7252,0.059487093,0.5418631896188945,5,-94 +9,19,6931,696,2958,-8519,0.10817439,0.16657239276877756,177,-8 +165,0,4548,798,4727,-9035,0.82912904,0.7971123584102802,130,45 +128,43,6385,-566,7300,-6207,0.26201648,0.025107594308950598,83,26 +199,-97,3044,502,8493,2310,0.2668948,0.48052049667249697,63,-29 +91,27,4389,247,8460,3033,0.10081636,0.8696422080680498,82,86 +0,71,8875,428,6138,6150,0.80923754,0.5615647856042404,64,-103 +164,124,7449,495,1100,-8862,0.24836762,0.2555062573800263,93,-8 +172,-120,3352,666,3569,-3738,0.58383226,0.5919060749881876,252,-65 +170,-26,6353,252,458,3975,0.6016361,0.5162052178803143,97,-69 +208,26,6910,333,8706,8352,0.41264114,0.018217708061770144,50,-79 +163,-10,4712,-903,8600,2735,0.5476896,0.8413279657575992,80,87 +162,48,7373,294,8621,4009,0.032648284,0.8257057957426217,232,109 +243,36,2594,-570,4806,-6427,0.5242275,0.1666044267120378,180,-48 +141,34,5118,986,8090,7025,0.33133084,0.04445983091294747,5,-73 +64,111,8127,-366,9946,8810,0.9044695,0.7343535042731615,94,3 +101,19,7091,956,8713,-5775,0.11652518,0.396283599953123,241,102 +220,119,8217,735,8217,5912,0.2805469,0.1509622842298618,33,43 +40,71,2933,156,4762,-9556,0.8102539,0.7668737582361018,34,0 +54,15,164,45,7104,3751,0.17452836,0.6896672012956572,182,-77 +67,-49,9880,-69,3254,383,0.32975066,0.06076139307943007,29,-102 +198,52,2634,-706,1526,-2061,0.97732234,0.7545302718884783,25,25 +231,25,9205,-775,954,2031,0.49193707,0.07116415207081794,246,99 +46,107,9802,437,2220,-8035,0.93911254,0.043929107194369266,28,-80 +48,67,2946,480,4034,-6463,0.47859713,0.1455375724700777,245,-94 +77,-64,6936,-378,4105,-9370,0.74383366,0.5265970049980895,125,-20 +179,48,7352,16,5594,2580,0.111753635,0.05942892449648152,128,42 +227,121,5996,553,2202,-1515,0.6151901,0.5231226429380005,38,108 +236,-112,5763,348,9341,-973,0.17078266,0.8689899004548158,174,-103 +9,-106,2713,-69,1955,8524,0.6675252,0.9321000236055854,114,-42 +225,116,3759,-410,4016,-3815,0.60060966,0.9698694752894785,206,-100 +185,-12,1691,-851,8443,1313,0.7006248,0.7746761103891379,115,6 +79,59,1237,-83,5476,-1492,0.16944806,0.511835958901601,215,99 +97,-86,4142,876,4782,-5791,0.4540523,0.8659601237667104,247,-116 +166,-77,6260,-538,4862,-8944,0.6162543,0.8515566648930462,34,122 +156,-56,5024,-549,8356,9256,0.42313138,0.15128046611580082,3,20 +64,-12,2904,-129,9586,7892,0.6243649,0.2592035303202166,0,62 +183,-91,9697,665,5172,-9102,0.9390311,0.9187818301727989,204,29 +210,103,4793,-676,9737,-2732,0.4887304,0.7740128769195279,66,-112 +23,83,6087,770,1140,-240,0.8993531,0.6432258085522787,22,117 +98,-90,6076,269,3330,-2,0.32933486,0.7360941366759179,13,9 +172,-92,2465,461,1825,-1388,0.55926377,0.34378758780537955,188,45 +193,-15,4181,-652,9382,-7529,0.6370253,0.6481984541362497,20,-122 +49,24,9969,679,4584,8643,0.9403101,0.40044398159290306,208,-109 +226,88,4175,949,9110,6458,0.59084916,0.6006138689962837,56,-84 +89,89,7409,-97,8635,-661,0.03740932,0.06932096970215629,241,-93 +5,-88,8476,697,4990,8172,0.50782585,0.6517054310897019,176,47 +92,57,6755,159,7820,3548,0.1430666,0.5497876767293961,171,-98 +167,37,4226,-592,1976,1787,0.14538184,0.9055739592736898,43,-88 +142,-94,6638,352,6634,-5013,0.7235463,0.939780376955046,169,127 +176,-111,7969,503,3991,-3877,0.58268535,0.041215161602960904,51,12 +180,70,5370,561,2592,8276,0.043589227,0.8798532523113667,24,-4 +221,-8,9596,-630,7319,2582,0.38691056,0.7458771091528674,101,118 +167,-11,730,-624,7207,-9176,0.33728576,0.8828848822218964,187,-58 +115,-43,65,-513,3699,9646,0.029289164,0.7372653334784406,85,-108 +217,-63,961,28,1751,-7890,0.090957426,0.3307634143735022,178,119 +54,-19,2499,444,480,5859,0.87281924,0.7539238299601405,151,-85 +151,-82,9806,680,5469,-883,0.16091388,0.8903482754423145,38,-19 +177,77,5267,257,920,4329,0.60098195,0.537674568671523,241,-18 +25,26,843,847,7139,-4551,0.36480775,0.21356852953141037,11,61 +216,-97,838,883,6158,9363,0.53055996,0.3432321324682932,190,126 +88,-62,2414,-660,5371,-9038,0.0529992,0.06505524815834329,181,36 +168,-35,5312,714,6632,7519,0.123923615,0.7674670103250408,43,95 +216,-41,3914,757,7290,-5295,0.68993706,0.468766019523557,122,-48 +254,92,1156,-614,8734,-9279,0.7478967,0.21827533585234815,141,-55 +172,-93,2113,-736,8287,-4540,0.6324234,0.27215260925038454,155,-37 +205,-99,176,107,866,3918,0.9057735,0.3920594453464762,211,-20 +58,-96,1005,-334,854,-5636,0.5079939,0.5489901028230629,64,124 +48,97,8317,-844,1704,-3846,0.5683624,0.9678658788360962,87,114 +194,98,9281,874,6219,3481,0.7856439,0.19500180199063832,113,116 +168,50,9087,-499,100,4720,0.7910271,0.904078302022101,101,-43 +218,88,159,-157,9072,-131,0.6807736,0.7508287409083415,244,-69 +112,-58,6581,67,9982,8934,0.1694619,0.43249979501533453,228,116 +104,-50,8464,611,9923,-1718,0.25932664,0.17961653156210833,140,100 +42,-56,4887,-235,4193,-1707,0.16992164,0.046701410918096875,20,-84 +4,-64,3123,373,7897,4310,0.17176963,0.5944147300596676,162,69 +159,-92,2271,270,4459,279,0.089192994,0.48866599896957275,43,-114 +74,-13,1967,95,6758,5696,0.5818816,0.4762608528086222,159,73 +148,115,9076,-456,7106,-2472,0.047606383,0.30080970400521956,57,53 +189,77,2479,81,2045,4546,0.5544721,0.2686188766794787,6,-101 +186,-93,5097,802,7062,-3589,0.14223816,0.37924952553218005,30,29 +55,109,1148,183,5409,6149,0.34346816,0.0851444766671231,40,-127 +248,-108,7213,-271,3107,414,0.44910172,0.5504668131609669,127,38 +154,64,5444,-422,3027,-8720,0.93907464,0.5936371515089808,152,-33 +251,-94,600,765,9799,7791,0.9340038,0.7155009367809494,236,53 +230,55,1373,698,9031,-6597,0.8746875,0.026372911420386336,143,88 +216,118,4705,841,1951,-2211,0.87568325,0.40096136795854986,173,-62 +251,22,1930,983,97,7771,0.93247443,0.161551470970422,246,-106 +44,2,2858,885,6654,-6631,0.17220193,0.020774470043254945,87,118 +243,-2,1735,-951,5271,-7646,0.56850386,0.49410343392216494,79,117 +172,106,96,-672,993,-444,0.4667163,0.6533232099699718,140,60 +58,121,7726,643,4006,-7600,0.78426135,0.0027650994046872768,144,-47 +145,60,6841,-379,2524,8748,0.55014694,0.704208667669453,123,104 +34,107,5267,663,6869,-7830,0.76249194,0.9598086591374534,84,4 +121,17,4765,536,2859,-6889,0.62080973,0.8518286712215226,56,97 +24,-55,3648,-154,5660,2227,0.8595469,0.9281743041969684,91,-76 +28,-87,3298,-465,5638,-7425,0.8999139,0.8312717382051321,65,-71 +114,-84,7407,-274,7088,-2530,0.9503693,0.8434720548828536,44,5 +28,-106,8509,895,8328,-4693,0.4334332,0.7600781421325764,139,-113 +74,-92,6700,-295,7714,-3263,0.6262645,0.2722542429526795,33,-84 +61,81,3146,-137,475,-5088,0.55602163,0.5567545658893918,201,76 +157,53,6761,-35,9273,-2247,0.27649042,0.5526937822140832,180,114 +245,117,2048,353,2917,8814,0.7858085,0.39955735488427024,188,77 +253,-1,2349,-285,9670,44,0.80239576,0.5637183030934433,182,-64 +14,106,87,791,7259,9355,0.96378535,0.30936796389084653,126,-28 +133,115,6424,-32,8949,-1485,0.9850067,0.16265871012797328,56,-40 +99,-41,6636,828,6556,9422,0.9951695,0.5589751106923764,117,55 +214,22,9439,-182,210,4686,0.5194249,0.5602070713436194,42,36 +89,-89,129,889,6775,-6342,0.4848622,0.36196838195526637,223,117 +125,116,1725,-339,5334,-9352,0.7216675,0.9166129475773387,224,0 +246,125,7721,-370,8572,-9332,0.6336274,0.5349877934636955,147,116 +145,-122,6603,746,8636,2746,0.5596225,0.6554637350428629,229,125 +184,89,5434,-927,2544,-781,0.06234782,0.02595691413472767,67,26 +4,56,841,702,9754,6377,0.93086654,0.9492785732174152,171,75 +104,-23,2396,-810,5320,-6812,0.61234164,0.5148868802736957,87,-57 +253,-53,6581,-743,3730,1996,0.898693,0.5134488720981877,149,-107 +117,-86,7469,-295,7819,2385,0.4252276,0.4031297485373363,184,121 +16,56,9370,-300,803,8586,0.84554577,0.40967579888339334,94,-60 +104,6,7418,-957,6414,-9099,0.3336174,0.47196566307977705,12,67 +72,3,9008,51,8494,-8677,0.6094125,0.6904238543261882,153,-77 +225,62,312,922,2079,1901,0.47991166,0.127080436049413,22,116 +9,12,4391,-812,313,-7817,0.54824233,0.8549218400409512,53,108 +249,-22,9471,124,5788,3640,0.43473306,0.6351539754760444,187,-38 +178,12,6527,-82,398,-9263,0.18800487,0.12937474164625795,21,-107 +179,33,8430,-92,8279,-3803,0.9252055,0.6137052551441964,186,64 +5,-104,1780,-863,3715,7725,0.6622289,0.9022930932942483,64,-102 +150,-122,6667,-330,8177,-2106,0.29695404,0.07765616364919092,18,41 +103,-103,9239,365,7412,6868,0.5918422,0.3441753321035531,68,113 +48,43,5928,-111,202,552,0.6261208,0.7040372785386015,49,-24 +214,-13,8152,920,5802,5572,0.48497126,0.19298706625837114,240,64 +184,-100,4702,-332,2496,5770,0.59616286,0.8865002529368082,71,-46 +46,24,229,950,2018,5951,0.1557792,0.14753549097234342,234,92 +154,-42,1788,768,7561,-5899,0.031857792,0.4793922589021804,18,50 +10,-72,1760,-819,2949,-4350,0.9294153,0.34795041422518624,94,43 +223,15,3404,218,9186,5909,0.34384468,0.08927777450609597,38,116 +79,-12,3052,-224,3225,-2202,0.109068565,0.5268797914507733,78,-49 +34,77,945,722,6596,-9856,0.4956646,0.24831567830329038,204,66 +168,-107,8608,780,2281,-4079,0.7306482,0.02239527850978673,56,35 +118,13,6225,610,7931,7668,0.40588525,0.9242927446066003,85,69 +175,43,6017,-729,3246,-8976,0.07636823,0.8727401485659569,51,59 +161,101,4245,-217,1258,-5482,0.7167586,0.1027172444114296,135,49 +48,101,148,430,2133,-9202,0.7559712,0.1692928119703372,205,-63 +78,-115,293,-975,8556,7670,0.8671408,0.8326903469465724,212,93 +31,-42,8530,500,3570,7883,0.36930123,0.008780628475305918,128,-109 +75,-14,2446,-658,3035,-1495,0.7816017,0.25017790837294196,59,106 +74,58,9304,499,4564,-8490,0.542577,0.27392804659886505,225,61 +36,-71,9292,-707,2016,3684,0.49649477,0.6931544402427263,27,-71 +39,-47,7609,46,4906,9558,0.68205494,0.4313479148549041,200,-13 +234,84,3073,-622,5728,-2864,0.36743513,0.22041936798475692,134,-29 +202,108,8223,69,8579,9137,0.55345786,0.5284508417534344,222,91 +137,-97,6760,-466,4380,676,0.8181546,0.3276404457869474,178,19 +138,67,5886,-598,5609,-7767,0.027894316,0.17518023894815293,235,64 +115,-44,7370,771,9658,-413,0.04079576,0.26875623295953643,2,-28 +66,-126,4343,446,82,-4879,0.791674,0.0899014519616752,25,-105 +244,102,7170,669,9722,-7413,0.22412711,0.20172559305484505,11,-63 +57,-95,840,713,1435,-744,0.9737317,0.13216779759056085,241,-25 +66,33,1504,740,3778,6088,0.9765724,0.5274202066082283,128,31 +111,20,1114,-358,4700,9092,0.31939402,0.889943369336124,163,20 +240,8,5914,-584,2411,9476,0.8177173,0.5450195437923873,50,-24 +10,49,2014,120,583,-9558,0.29767874,0.6140215602464288,230,-92 +69,63,1845,-143,998,4497,0.6910984,0.20307971225231503,195,-105 +48,-46,66,175,3743,3593,0.50676394,0.9906934454756691,156,-122 +146,112,4514,-164,5427,-4464,0.6225665,0.23294040265608296,212,115 +212,73,4707,-791,5561,-6501,0.17469268,0.5990191341262846,74,81 +106,-59,4042,756,8670,-7731,0.7999738,0.25323527315150707,101,-110 +60,-102,8987,555,3970,3446,0.045120377,0.9620451317300411,145,96 +11,28,6930,-736,8350,5043,0.14350453,0.8697190204256895,253,110 +61,57,5228,-258,920,-8509,0.4727988,0.34458684899815883,4,72 +3,-102,3045,673,6063,-8729,0.13758434,0.05615614782733047,119,114 +46,-82,9878,-100,7521,4597,0.6892768,0.19489223022857638,145,-62 +44,-57,9994,701,5888,5460,0.11618195,0.36000958675087424,227,-24 +227,-49,253,687,4309,-860,0.9824833,0.004472256132969643,130,-20 +187,-90,9511,-641,3696,8487,0.85672975,0.8925237264143306,232,-3 +220,57,9283,772,9173,2964,0.01842143,0.8384620787068604,222,-3 +133,-97,6711,359,4619,-3717,0.14900449,0.7367246994308203,211,1 +99,46,8992,145,9752,689,0.3096363,0.6826728116407144,200,-65 +137,-27,6303,-961,9912,5502,0.22776884,0.672810040188421,20,-25 +149,112,901,871,9618,7421,0.64919144,0.5099916206049782,174,-112 +204,-70,9825,780,6166,-986,0.92740667,0.9407499689250505,219,-106 +30,127,8588,-145,3714,-5237,0.88895977,0.09877694631817924,97,51 +183,5,5042,-447,1070,-4501,0.7787836,0.802216524039013,250,-29 +215,114,9357,-50,1642,6550,0.3539051,0.09665834361385206,166,123 +156,-101,5600,230,4894,1415,0.069768965,0.3298096700420128,99,-111 +113,-34,8728,-795,9226,8504,0.863932,0.456071914869438,190,-121 +69,1,9243,-558,8373,3993,0.5836685,0.6082281500727874,235,-4 +2,-88,4732,-487,449,2094,0.75421906,0.5432549620647101,239,30 +163,125,5344,-503,4999,-7921,0.18097267,0.09246957248432197,31,-52 +159,102,1685,295,6460,1450,0.3543259,0.7625879173194096,25,-37 +39,-102,4488,868,1349,-7690,0.36838436,0.1274518921531388,23,-75 +31,-110,2795,787,2133,-8863,0.16041303,0.2453678428460747,246,-84 +139,-94,3670,660,8480,235,0.04348971,0.2532453628150818,71,-5 +78,36,4615,-722,5215,5539,0.660686,0.6766337266539445,181,23 +193,-92,9224,-605,1961,-9793,0.58322126,0.9156100103775917,99,-107 +81,123,7823,-341,572,-4531,0.58398056,0.8632642161165558,229,120 +193,70,2921,-68,9308,-7646,0.18366043,0.12218371156548591,160,-67 +235,81,7249,-26,9874,1384,0.07464494,0.49107052416575714,8,-47 +221,-45,8301,456,2964,-9953,0.63797826,0.15438941498125702,65,34 +109,10,1957,-786,4856,-6437,0.7087497,0.7430639513020915,202,41 +85,-74,6006,-690,5140,6991,0.52394503,0.21227653172709626,230,32 +213,-88,3506,-414,7307,2976,0.18348318,0.8453623694610598,214,-104 +220,-51,4315,-917,9616,-6510,0.23338626,0.04091961243225528,33,127 +39,59,1476,553,1256,-9377,0.5450769,0.9672691001725781,212,-48 +99,2,1445,952,9858,9970,0.6439298,0.5823170187466313,130,26 +58,-3,6472,-756,9983,-1282,0.41773978,0.489195932734793,78,-6 +80,109,3319,-253,603,-6934,0.7456001,0.9556366006214851,37,106 +44,-60,8511,803,9520,-3032,0.9516745,0.09153698671088684,14,-102 +46,-2,7115,422,3441,-8695,0.07731925,0.6855489739297618,222,3 +62,124,4416,504,9671,3708,0.062871404,0.5952020335167953,98,7 +145,-80,522,-634,1467,3090,0.5680766,0.055388456667615604,105,14 +25,-127,1477,91,5155,-8668,0.77476436,0.8117157178747533,180,17 +140,76,9211,-107,4258,1176,0.34407797,0.7377518680016038,58,93 +94,88,959,-344,2124,-4913,0.66068774,0.29879482155068093,204,-102 +171,62,8975,-666,8726,4101,0.008127313,0.8544770598467027,254,-35 +73,-19,44,232,9904,6300,0.65485525,0.8605378799500473,94,-96 +219,-55,9051,-429,8302,4429,0.49772194,0.35847442558154985,19,-20 +27,-119,5939,-329,2305,309,0.7602337,0.8585256623434251,149,-116 +198,-28,497,316,6385,7055,0.98297775,0.6489809934788578,108,63 +11,122,5580,712,1788,-7579,0.6674185,0.12944645609789918,145,80 +147,107,997,842,9642,2696,0.6844942,0.6753943267986124,34,-13 +207,29,2081,-148,5630,-5603,0.93678004,0.3798239914495015,199,51 +52,0,3709,-659,4341,5600,0.035664845,0.224851755041515,128,0 +5,-7,9914,787,7686,-4291,0.3933109,0.9463425516884376,46,112 +10,51,7708,-580,4389,-8355,0.10752103,0.2434198779665423,12,51 +138,114,2419,391,7499,-1756,0.36492935,0.38001214800103844,98,-32 +75,4,2873,-838,751,145,0.93725055,0.6873102473356489,77,26 +178,-56,6556,-234,9441,-3614,0.5388174,0.8079176304143162,12,1 +194,66,221,-470,8125,9881,0.06638847,0.6573416444274675,106,-68 +25,106,4656,202,3568,-4967,0.1712805,0.36140162967769396,3,-26 +4,-76,8260,-209,2154,331,0.89401686,0.6582734512641446,59,-112 +205,47,1533,581,7712,-7624,0.62529397,0.9022701926080885,33,91 +158,-67,6687,-117,2625,5091,0.7845083,0.9783825177685662,204,-52 +114,-28,7746,-963,8333,3781,0.19174072,0.5088175683879028,226,-121 +37,-92,5630,168,2370,-7851,0.878602,0.2259700895057818,61,-105 +223,34,2503,-130,7325,-9826,0.16470446,0.8535662863961271,247,-16 +55,-27,5656,-925,9380,6122,0.8423506,0.8643932912008659,9,-58 +12,108,7780,-382,1632,7167,0.9490369,0.6856373896271761,185,70 +93,-126,6982,-186,8441,-7830,0.48999667,0.7134265773750175,145,-99 +53,122,4505,859,8353,5176,0.09115398,0.8622964518776357,134,31 +156,-72,7521,12,7435,-2635,0.7399544,0.7374084031678673,194,75 +57,87,7688,335,3304,4055,0.0051739844,0.6332652530726409,101,-85 +32,76,650,81,4333,3473,0.84946364,0.9286373823599386,252,-117 +184,-115,5103,82,7423,5869,0.36074075,0.6641585021725707,55,121 +39,-49,7551,-329,6187,-1797,0.21539336,0.3828921659947354,245,-82 +240,79,3901,-572,4960,-9584,0.26005656,0.7192696907847356,183,-18 +142,-87,3552,-198,6281,-5961,0.36651036,0.6857425814084261,3,59 +78,4,872,737,5289,6075,0.684301,0.7825079336020737,201,11 +35,-22,9002,-562,7075,878,0.22197178,0.985191304480872,178,-50 +94,-106,2711,-941,8804,8321,0.80063397,0.19383052381622312,23,83 +210,98,8846,124,5704,5395,0.47631708,0.24423320283028238,57,-94 +189,-79,1366,768,8751,6178,0.011637804,0.7557359749035873,128,-99 +125,10,749,-31,4618,8396,0.31128716,0.48689054287788525,29,60 +155,122,3249,-473,7105,-4121,0.34549323,0.0034196611637644647,83,-62 +18,-17,1410,-415,8982,-1057,0.71132153,0.6355788450778952,70,-13 +219,-56,4567,957,8245,4030,0.23464198,0.7905389207993686,149,-121 +58,12,7127,-694,5421,6839,0.6293876,0.3970659239182337,247,101 +225,-42,6044,527,4676,-8687,0.42450097,0.7818823130396672,210,117 +25,59,6683,696,4722,-7059,0.352719,0.2762081026266495,136,-116 +110,-127,9535,-20,9214,-8306,0.18184584,0.6611266447313274,57,101 +242,19,161,615,9388,-5317,0.42933163,0.6849804636553375,221,-82 +146,37,3614,-105,1542,1698,0.831649,0.14192821723448068,64,57 +94,-12,320,-461,6103,8265,0.56891227,0.8648399433354484,8,-82 +45,8,3690,-434,614,1809,0.28032747,0.28927835795470624,126,-64 +249,79,4231,503,7357,9445,0.5477521,0.6654139613098088,188,58 +180,-29,7724,-239,7171,-8400,0.8894303,0.9467758749038636,159,-29 +111,14,2625,954,7991,-2726,0.5904124,0.8224298603895049,218,38 +85,22,4774,622,7090,-991,0.2765813,0.4088158583396617,215,84 +2,-30,9911,-656,1299,-3278,0.27598375,0.9972270025932958,172,-49 +4,121,4708,542,5589,3761,0.33137023,0.06198167767609042,44,-66 +37,126,2936,-261,9108,942,0.8279049,0.9745407342683292,207,-81 +243,-86,8112,-239,6215,1194,0.25182837,0.6267748574406636,219,-30 +95,-103,6279,135,4506,-6600,0.64597595,0.39245918252864864,105,57 +110,38,8412,-492,4232,5693,0.24564992,0.5230010924590273,6,-75 +229,-128,1861,577,1143,963,0.09786583,0.7261749706458454,111,-21 +95,-126,5545,884,726,4363,0.053285107,0.58884093564713,122,-88 +72,36,2658,-759,3770,-8886,0.8807222,0.945812680578732,59,-107 +165,-62,8652,797,4749,-6981,0.3772409,0.05336092931525682,143,68 +42,121,4460,426,273,-2183,0.6767403,0.4800287254921931,10,72 +81,64,2490,-132,7781,-3480,0.011503393,0.8221737495539889,141,-49 +175,-53,1131,243,5333,-1496,0.15413825,0.43527777037326365,11,124 +109,66,1564,709,1371,-5677,0.13965751,0.7947129497849607,163,31 +10,-126,178,-667,9190,-4965,0.70095956,0.51987085181656,206,91 +77,-26,8047,-507,5224,-6550,0.8118403,0.7746326819601345,80,20 +113,9,1909,-511,116,3444,0.057263244,0.5601450130632889,5,-104 +3,102,8471,445,463,-7645,0.72745675,0.7539778978840583,55,72 +39,-48,4609,224,9078,-8629,0.87705153,0.666511299668877,74,-89 +169,24,3048,-715,8903,-8477,0.4313278,0.1296152139021849,254,-48 +120,88,6792,725,6914,3155,0.74181277,0.510963424222271,172,29 +230,53,3662,-583,55,6588,0.8413361,0.39963570156451755,99,-23 +35,23,8087,977,4759,-3426,0.3385379,0.4523280808390645,56,-47 +6,20,1094,-489,4674,2516,0.34570146,0.6585250666792258,66,53 +0,-74,3757,483,1806,559,0.12860267,0.23904275322405166,222,-39 +64,102,1249,895,9900,865,0.5694047,0.14790588009116745,69,-61 +187,88,9674,-740,3733,4309,0.33097184,0.3554866084128292,215,25 +135,5,5343,-981,9057,4680,0.12620687,0.2909160014532485,113,23 +123,121,968,-267,2699,6176,0.5600654,0.6491447131722303,147,38 +245,-19,2886,953,4280,-6536,0.72959536,0.1540468752616846,223,-14 +162,98,3718,91,3623,-4935,0.2887361,0.05924188508159911,21,-114 +188,123,4801,-602,7102,-7478,0.4810454,0.7069559904595467,255,-42 +251,80,8494,418,9925,-9583,0.99759996,0.2879201976029352,50,95 +172,68,9633,-116,6225,-1063,0.013157089,0.2003255385803916,66,46 +193,118,5898,629,4014,-3707,0.34797087,0.5737595874945349,174,-44 +251,19,485,405,3696,-245,0.72216314,0.49583529600156717,175,2 +99,94,5657,-680,8789,-1525,0.11735575,0.32940446085643216,155,21 +220,-3,5917,97,4623,-9374,0.28786227,0.6493110112281435,47,25 +54,-7,1409,472,605,-372,0.76291984,0.9359375158713349,201,-103 +142,8,4,345,5659,-179,0.74109447,0.32340039962236167,138,-105 +149,-80,8853,461,7620,-9172,0.36286303,0.6988133113680323,155,-76 +40,-69,5025,-296,1772,-8472,0.99777806,0.5772408558005291,50,122 +18,-27,7193,873,7779,-7757,0.25364166,0.9355860262784728,61,-27 +36,-53,3811,754,8214,2922,0.7151183,0.2707613409727755,76,-32 +223,97,5958,428,9404,-2191,0.9957794,0.17850523062887302,247,-97 +90,-10,1279,662,1025,525,0.7703582,0.793007281259094,128,59 +173,-46,6371,-627,9315,-6179,0.20606548,0.8411113590920221,73,-73 +68,45,6865,615,626,196,0.58550704,0.08752249744443419,143,-8 +169,-38,1315,213,3180,3718,0.8084003,0.11664157562821831,163,-37 +146,-123,7118,991,8295,7075,0.28150973,0.09843947681578491,143,112 +173,127,9379,-427,165,2683,0.7945203,0.3706638821582511,161,104 +121,-50,4651,898,4900,4608,0.13236003,0.7278462902747573,102,-126 +15,-109,7586,-871,4290,6046,0.84341663,0.3366122510781142,195,-120 +32,-56,94,876,2004,-5021,0.74091834,0.8829219946630865,242,-17 +138,10,4991,-258,2797,-2585,0.12509955,0.007282197570440574,190,51 +61,-85,5254,-118,3023,-9247,0.5972858,0.6735156773168327,59,-70 +243,47,6140,492,2353,9364,0.28911775,0.3043886810514982,136,-26 +178,126,5427,175,1419,-1887,0.09134215,0.16258077146777017,11,55 +86,-89,3469,408,8941,-7632,0.6866711,0.7692904619455548,103,109 +17,-70,7850,-194,7742,-6845,0.9709262,0.6246115147590796,197,118 +0,48,7273,-437,5573,8826,0.6612462,0.6580078048209286,250,40 +11,-118,6931,354,3993,-7833,0.06674277,0.6471301984250472,178,78 +154,122,7250,-917,7933,-9865,0.122665524,0.4659526459238037,210,-80 +67,-98,9736,763,7502,6583,0.79388607,0.4597365425514852,246,-112 +114,-111,9710,33,1263,3624,0.27021435,0.07713033456309726,70,-94 +17,-84,221,-445,3942,-3029,0.80176145,0.009359927573738713,209,-32 +255,89,8352,-796,6323,5992,0.9202702,0.2883298382324515,119,87 +131,-126,3621,-358,2180,9974,0.17361563,0.716120740319666,151,37 +31,102,7873,354,4255,-1477,0.42498538,0.5321189260725078,224,75 +241,-93,4769,-956,3883,7195,0.18094352,0.5534593898716986,76,-14 +19,-54,1876,-710,6481,9769,0.41613197,0.7616059184199488,238,96 +207,98,2520,-690,8072,-3031,0.96655566,0.3233574360738004,141,98 +84,23,9726,52,187,-7687,0.410438,0.6740454390928564,41,32 +206,-112,1506,-939,6383,5721,0.5711479,0.579205989914004,154,-76 +219,-30,5049,-842,3805,-995,0.36242163,0.9920354859110826,223,124 +7,24,1617,754,1300,-3839,0.17878173,0.686634533580629,75,61 +185,57,4940,-978,2832,5334,0.2363072,0.47125693905239907,57,65 +3,-10,5565,-609,8698,3123,0.10798046,0.47258665169371605,235,-33 +58,-108,5004,-963,3749,-5852,0.7449235,0.24365562165448174,106,-83 +178,114,3455,-932,4696,8828,0.5799511,0.2873683014628119,70,102 +18,-17,1154,403,7259,-6865,0.6652689,0.3564979028665506,36,107 +41,51,3639,217,3351,2531,0.36003777,0.8682644199842833,55,-72 +63,109,8965,-507,8351,8464,0.9737447,0.006919603741065594,88,0 +201,94,8053,-58,3941,-3011,0.7897736,0.4128791987085605,148,-61 +66,-82,1957,-386,9,9702,0.16003652,0.08900477776966154,191,34 +47,-71,1550,216,3875,8486,0.4954202,0.4869444791489781,123,90 +78,42,1713,983,6869,2123,0.555331,0.4824369252506474,14,-58 +182,-50,7633,-263,6008,-6910,0.2354769,0.5142741777553984,236,-1 +56,68,1736,-126,7848,1489,0.005946972,0.4973098175249674,188,106 +25,-84,2625,-34,5167,7771,0.5723965,0.31085979362000193,118,-7 +191,47,5829,586,3985,-4312,0.8960583,0.022358736863041684,156,78 +64,-41,7716,-530,8830,-1872,0.34408286,0.5404325166745853,182,26 +202,-51,307,-778,2314,-5263,0.039343417,0.7566726882964305,143,-82 +134,-71,8991,-989,6005,6345,0.31457275,0.032571655647034015,242,61 +215,-6,224,-852,7580,-2452,0.19308154,0.9494289986282048,34,-123 +158,115,3561,654,6637,-8770,0.64863086,0.42401206974387196,221,26 +42,-82,7978,70,3483,-6780,0.97174823,0.6470567364290265,51,-100 +128,-92,4267,-765,8532,131,0.8973459,0.10582636633911069,207,-54 +86,-19,3927,-740,8366,8348,0.5034029,0.08748956261577723,185,-50 +130,122,2753,113,823,-76,0.29379013,0.20445820310486085,249,72 +224,-23,7071,-874,5068,-4494,0.7476506,0.674483191363776,127,-45 +37,37,7633,-78,5020,-721,0.19658646,0.5434687051177566,138,-83 +75,-112,6194,768,9315,-3657,0.11198892,0.9415808858484682,221,103 +156,51,503,-530,5156,-6265,0.3831483,0.23693571949013148,210,-27 +119,-95,9678,483,2121,1489,0.20767996,0.05793420064109844,48,-91 +217,75,1969,522,4149,-2879,0.2818282,0.1937156085177677,101,-66 +24,45,9129,885,4580,-1875,0.11045572,0.7712491207403576,2,123 +240,-9,8192,933,7021,-278,0.7182949,0.41006824972301115,116,16 +112,-126,2313,-270,3490,-9326,0.39607725,0.6501843841303321,83,91 +208,1,7364,-153,7421,-8166,0.15934128,0.42562958638092696,104,-88 +214,33,2531,-366,4755,3246,0.7639846,0.7637867148188406,70,-5 +21,83,8564,273,777,8458,0.29139557,0.43918091189742925,54,-91 +251,-23,3538,533,7541,4693,0.93629414,0.39876336005400614,111,-95 +177,34,2420,-410,5416,-4264,0.66216385,0.9172368497441937,7,-91 +133,117,4442,763,9070,-4569,0.28909278,0.7247520467293994,202,-128 +48,28,4400,319,7947,-8640,0.16548373,0.07980407209721396,189,38 +95,88,1603,-377,5064,7865,0.20844203,0.6418486136182162,174,95 +71,21,7977,503,3391,-4705,0.2900548,0.3057212251324428,245,-21 +142,-50,4786,143,3220,-6933,0.04369075,0.8851008867157771,184,-50 +171,-16,4816,164,1646,-9326,0.2901531,0.75116117872615,1,-63 +26,-38,1342,327,8244,-4626,0.5133798,0.3078831814639992,196,-12 +12,65,6580,-179,81,-8625,0.72188705,0.16238263478491077,175,32 +41,-112,1584,194,5057,-3647,0.48680496,0.8827577605704424,15,120 +171,-34,1997,-641,7782,-1786,0.8997873,0.6558096554807882,155,70 +14,100,1977,97,2001,3830,0.59882116,0.9928913390213511,161,-57 +35,-123,2086,-652,9662,7658,0.85585,0.6326504511008736,1,-79 +58,56,5997,361,9700,-6636,0.5920224,0.8006354260001416,56,-114 +202,65,3004,-701,5477,9611,0.06691792,0.13128235899871543,130,121 +55,64,4371,906,8048,4933,0.3142313,0.3497847802897771,104,-109 +53,18,9955,346,6601,-8876,0.5680121,0.8050848327809733,171,22 +133,58,6374,814,3177,7437,0.8529105,0.21307264245182234,86,-97 +23,13,8661,514,4247,9220,0.62118,0.37154634410707454,21,-64 +96,-48,9428,-483,9911,7849,0.75193083,0.28511738257335706,34,70 +108,-34,7811,888,2288,-7202,0.928094,0.4815064601236685,88,-127 +201,117,7275,-72,8137,2195,0.1518562,0.8155006321018079,227,82 +231,-94,1928,575,7412,-2659,0.024682665,0.43567481905899874,28,-28 +50,23,2120,208,3999,661,0.31690705,0.35834971406890226,231,-7 +81,-20,1147,-724,9440,4786,0.5352984,0.6184198166737356,9,29 +201,-23,193,-997,8964,1874,0.7461596,0.09333871947776828,104,10 +238,72,3019,-718,1915,-2064,0.52942675,0.9340844938157009,162,-96 +85,68,2715,-181,7778,-6566,0.96915406,0.29183177229363166,120,77 +50,14,2652,475,7143,-3282,0.63491946,0.23246681348784315,183,-98 +215,-108,5818,-705,7720,5381,0.14231104,0.6997289613331341,126,78 +64,88,9402,-384,5970,-2101,0.6985025,0.4990392946059704,174,-114 +91,-116,2592,-639,4599,7362,0.2919438,0.9073012273940689,92,64 +33,-45,7303,5,9333,5298,0.56008214,0.8269702706423493,132,-5 +60,52,7642,-465,1593,-5686,0.69842345,0.921621096905319,219,87 +246,-85,2900,850,7125,8696,0.025009861,0.7604963843758721,107,60 +64,-47,9248,295,7605,-3424,0.866836,0.5413944949193056,255,-122 +155,-57,8619,334,7807,2853,0.7943036,0.7017760828409504,65,46 +64,-48,2001,886,8638,1206,0.990505,0.8580054811680908,154,-10 +62,-100,4711,635,1887,3008,0.469282,0.9290500543384459,14,-47 +61,93,7201,-336,5026,-392,0.9780839,0.12784344223308852,226,20 +108,-46,4495,-251,945,-2768,0.0047660833,0.3636619535439304,75,-63 +230,104,2902,-980,1640,-5667,0.4852162,0.16316004207114643,122,95 +148,-83,3263,369,9413,1881,0.078026615,0.8002029104606657,48,-71 +58,100,5966,19,1237,4429,0.9813914,0.9527086129159907,3,-79 +48,-74,6271,-509,7078,8132,0.5259934,0.9582073634372161,234,-31 +170,78,7639,452,519,-453,0.9398112,0.9173203629899028,15,55 +221,58,9817,-622,4248,4636,0.7407575,0.33662610447732355,126,-61 +163,-26,8374,-165,7538,4919,0.55172855,0.8665841136493604,73,-15 +243,10,835,817,734,-9514,0.48096463,0.409429594618854,134,70 +70,-105,8261,619,9179,5543,0.76160836,0.35030522803941166,227,50 +23,-59,1282,-346,7944,2307,0.6175073,0.26459954505331307,86,-36 +246,-116,3020,781,935,-8909,0.9466286,0.3636641843518217,108,83 +25,100,1577,516,2021,8349,0.11701866,0.03018673749574985,159,7 +255,-41,3520,-290,2297,-3754,0.93891096,0.9623094555076019,109,116 +218,89,8488,73,1158,-1043,0.30382973,0.5832022800163785,79,57 +65,-38,5446,808,5234,2753,0.97006756,0.8362866231036297,91,-81 +171,102,3235,308,9852,8708,0.8651263,0.3489536196547872,125,-49 +239,-47,1069,-103,7761,-5298,0.961847,0.767431097294111,179,-50 +82,81,7071,19,6391,-9049,0.27938047,0.807818898456208,211,102 +150,-72,1641,-991,3176,-4158,0.48288208,0.48494023899970695,90,-27 +149,-20,8316,85,9701,-7450,0.9588248,0.27359468933174513,243,114 +83,30,2037,125,3205,-5832,0.12693037,0.6172624422340399,241,91 +28,-118,6290,-283,1742,3641,0.41616687,0.43236233111854505,223,92 +82,100,2829,-64,7424,-6067,0.18653016,0.45304602468984545,171,-20 +97,-124,9666,-44,7410,6274,0.29348934,0.5592557008718825,103,6 +106,-98,529,2,6879,722,0.93851656,0.6698535245072308,6,-18 +42,-25,1352,31,6565,9269,0.51120794,0.1155861733670932,25,-15 +187,115,5722,806,9720,9435,0.8186066,0.2510665032799372,137,123 +38,-119,2970,606,3169,-20,0.0005869934,0.5273902838266382,216,14 +157,59,6415,858,5039,2339,0.569492,0.1879935777855053,200,42 +20,-61,1695,402,6505,8229,0.35778567,0.2543647038169816,106,-85 +13,-66,4875,-255,6959,4664,0.7798619,0.7501571271234687,171,86 +209,-3,758,945,4160,3816,0.73214585,0.786378271941046,235,65 +211,-68,1309,-700,705,3641,0.26310882,0.5165171240072052,43,-38 +204,-55,4536,-451,873,1923,0.5765948,0.3399607782997285,138,11 +30,-87,8669,447,1180,882,0.86613375,0.8003714329828666,252,126 +105,45,2219,-330,2187,-8395,0.93972945,0.03051869427048981,251,67 +53,-52,1089,-799,2683,4772,0.30514228,0.6872379381545783,96,-71 +183,-45,2879,-450,8853,-2311,0.15022966,0.7678425055662508,81,-98 +105,-56,984,626,6798,7655,0.22430144,0.8534632468864309,192,17 +223,89,6131,47,6173,3257,0.9282704,0.6308935516760207,46,75 +31,11,7149,300,6087,-2199,0.851074,0.6569258904572813,48,70 +159,-25,1996,151,4135,-9645,0.07316858,0.11898481831932273,25,63 +167,49,401,-806,5286,6389,0.8071003,0.30628984893116973,127,-7 +173,-17,6573,370,2221,-5694,0.6368642,0.9279223613116709,73,22 +72,120,1606,-773,7059,2754,0.9795374,0.14168177806720839,48,-71 +37,14,4779,522,3465,-2805,0.10695671,0.011006354660512474,79,115 +6,-3,5136,-893,3367,1875,0.2844868,0.8199753831814621,45,-124 +206,84,9022,901,5531,6123,0.69824725,0.8347413417218889,224,-77 +110,102,3044,-33,8829,4964,0.6530227,0.34897103042180155,26,78 +174,-11,4758,-111,2724,8720,0.12613375,0.7447081159597695,246,93 +184,-83,9605,986,5590,2605,0.7341461,0.17614677243991206,94,-47 +246,2,9871,704,7022,1267,0.82507443,0.5524709081572394,162,79 +128,86,4287,-532,5155,-304,0.5206524,0.016363211577341885,224,-71 +94,72,5824,796,7996,-796,0.594186,0.3728056213370413,117,99 +114,-53,337,585,3957,6590,0.2877046,0.8357829492357362,246,-13 +32,-64,694,239,4117,4347,0.12374072,0.31829457954103524,171,13 +4,81,6658,-164,995,2000,0.9334642,0.6281832312325126,224,-77 +181,-64,100,328,256,3781,0.19220346,0.7410453251804351,233,118 +153,-3,1945,715,301,-9000,0.42635104,0.7319223207555684,66,64 +198,-54,5730,113,7866,-901,0.693012,0.22834116226650214,200,121 +224,49,1779,-9,151,-8079,0.663529,0.9041381809153803,234,-64 +223,-70,7103,-52,341,3083,0.15551676,0.09232246437282343,235,31 +250,54,3859,-994,5636,9486,0.319282,0.5742221807421968,235,-101 +68,16,8344,-502,5248,5264,0.505748,0.5326004006759546,240,-76 +98,60,8064,-778,5406,5828,0.54861605,0.18369611656033114,222,-112 +58,-35,8229,-672,2703,-9163,0.10332534,0.7156715020548,64,-37 +181,-92,940,56,3252,8509,0.90553015,0.07303060221229263,146,5 +51,41,7389,-931,7245,-3741,0.9815495,0.89500892051468,75,121 +16,-118,2339,-754,1560,-2879,0.24638556,0.5669079241960356,216,-53 +66,84,9074,-415,8962,1691,0.42206934,0.8906821267749231,209,-42 +46,-65,7778,-739,3062,9159,0.60525143,0.8709624838098139,255,76 +190,49,1795,710,1299,2932,0.11536299,0.9809217208125496,42,-111 +190,-2,6867,474,8929,1170,0.7769769,0.6319997227287509,228,76 +123,-105,732,-77,4465,214,0.50542897,0.44979175007424577,117,-127 +157,-42,1023,-388,2932,3733,0.61984855,0.2914420239835064,227,4 +77,-122,966,351,8125,3491,0.11982922,0.17115070066401727,96,7 +152,-15,29,-532,1924,5447,0.11613075,0.8515850254025843,41,109 +35,-128,6314,926,7371,-447,0.24158038,0.7549447280480052,29,106 +75,-50,7003,-634,5445,-1542,0.25055507,0.5149901720372543,100,78 +160,-63,3892,-203,3881,-2940,0.5209289,0.7130777475686565,86,126 +63,86,3177,414,1495,-5219,0.6197755,0.3006508806454463,34,-47 +110,-72,4481,-294,7791,-3800,0.43246168,0.4180985959139899,44,-43 +147,40,1678,409,1122,5812,0.4190952,0.9622442461778246,111,-86 +203,-25,9118,-794,1568,-7191,0.48656258,0.7120963691083658,123,-103 +174,-124,8026,-141,5557,-2927,0.9465642,0.968020182682334,187,-62 +241,0,9841,447,3700,683,0.30902445,0.20617040542887577,149,-109 +16,95,2521,-913,9051,1378,0.5354937,0.5586033748830135,40,64 +169,-5,1366,264,2863,-5148,0.54094,0.35638125341416516,210,46 +118,82,4342,-711,3433,-7642,0.062234964,0.5179842541234337,47,97 +196,-60,2350,261,2275,3408,0.95379543,0.03824963251699909,177,-72 +112,53,8385,-352,6866,-7218,0.3062671,0.8175735138951341,220,33 +63,56,6665,-821,6829,-4983,0.5026312,0.5372621276509485,127,-68 +249,114,5600,-766,4800,345,0.19102862,0.4285201558415318,185,104 +175,27,9740,330,6802,1184,0.04313483,0.8183609378608546,203,64 +243,-110,6518,-328,8843,-851,0.63287175,0.9135221661075035,24,85 +3,-80,9193,-316,9148,3119,0.7212472,0.21546718482357852,81,100 +199,67,9379,819,4838,-1346,0.37104136,0.9478055601661662,141,106 +101,-117,784,543,1593,-7887,0.8390213,0.05861048696770266,248,-27 +36,-21,6148,-786,2366,-8875,0.6845213,0.702572438285443,55,123 +156,48,173,181,9715,1570,0.61784524,0.8156649369261679,182,-94 +89,-103,6629,188,8434,-6360,0.94567937,0.06425984572038779,117,-87 +62,24,4666,-813,11,-2630,0.011226748,0.7761455415894122,37,64 +72,-22,2626,708,9858,4207,0.7850861,0.6917557462246435,164,-53 +36,-49,6679,339,8425,4326,0.37090623,0.5927936853538995,236,67 +248,122,8400,-288,2247,-3712,0.36412904,0.8758826624733052,226,-23 +155,-106,8976,-410,5657,-5215,0.8803647,0.6495870553469297,52,-33 +31,8,3322,-123,7429,2072,0.13017657,0.7405040781940204,1,-47 +210,-74,1593,-415,9807,-74,0.7626079,0.6573838783814013,1,116 +61,31,9906,-768,28,-6378,0.03280045,0.15985054022001077,175,91 +76,56,5128,965,2086,5905,0.25056523,0.1721887135967365,158,19 +162,87,9364,700,49,700,0.8483904,0.9911512283169227,247,50 +252,-90,3511,250,6888,493,0.1052889,0.3706544052278721,185,-98 +76,-20,6152,854,5642,-9040,0.927877,0.27985275742667703,181,-72 +91,-86,9035,800,7554,5239,0.65612894,0.41128177589660797,191,-28 +244,47,1287,447,5745,-983,0.94025505,0.1503978969516836,219,-6 +222,-21,7612,-887,4694,6808,0.8245816,0.9778334818145161,27,24 +114,90,6566,957,5428,4924,0.23987001,0.7017375891767037,42,-123 +250,-57,1908,42,3387,-5753,0.14355582,0.13667829315492963,24,14 +225,-10,6689,842,4265,3721,0.9727628,0.4176157773642414,240,-80 +244,-106,7020,528,5678,-920,0.534303,0.12294889593150793,245,-108 +174,58,8820,-943,5882,-1521,0.79355305,0.9376396910298301,137,107 +234,-112,3908,-472,4941,-9113,0.12876669,0.12822753638601536,93,-122 +216,-120,7761,823,5103,-8248,0.18058872,0.8964497361388479,74,53 +243,47,4285,-637,6288,2859,0.39275798,0.4513037183397506,88,-36 +29,19,1081,-932,9713,5632,0.9191904,0.15440603458777047,99,116 +50,-119,5301,726,7531,8556,0.5613592,0.22288850450297382,242,-33 +22,84,1072,-63,828,-5481,0.41791406,0.6349758915745206,126,-125 +8,39,9504,212,2237,8836,0.95368826,0.7715577479177244,197,124 +210,-86,8121,545,5581,7748,0.87390536,0.18287690738922546,68,38 +97,96,1059,-952,2754,7126,0.10920766,0.635842403673304,180,-41 +1,103,4020,-909,4717,-2559,0.40026695,0.029240328466080157,230,-37 +9,-106,4343,922,4185,-1185,0.60693514,0.21340389815583627,192,16 +6,72,8096,253,2963,-2207,0.022012934,0.49905759322626475,172,-90 +130,107,748,598,5806,2166,0.7052085,0.6244843107634482,151,-11 +60,-69,1272,-150,233,907,0.8637278,0.2984823109616703,195,5 +88,-96,2880,-552,3291,-4883,0.38781178,0.8867677008008059,112,-23 +35,-26,6636,8,2779,8993,0.12603615,0.42316759771728985,18,57 +88,42,5578,-100,4793,5531,0.4037198,0.9932624210408619,63,59 +47,-39,5407,25,3121,-7368,0.3270482,0.2971763164630674,93,-58 +5,-49,5422,527,373,1973,0.30364054,0.5755963470208022,215,-12 +104,-69,8874,61,890,-3897,0.181271,0.8806415135518815,77,-128 +61,-22,2137,644,9931,-6699,0.3705446,0.7616203112168161,1,26 +163,-91,1082,67,4448,-6655,0.63296384,0.648067931721917,234,-101 +92,96,502,714,5326,-5114,0.5160371,0.7244410359132561,148,55 +201,34,2008,442,9698,-5041,0.14719501,0.6457694206729241,227,-52 +79,-37,2825,725,7188,-907,0.8890552,0.9066855777355216,206,37 +171,107,6152,-441,8851,1466,0.41418445,0.17063372077994798,162,33 +181,-46,4716,977,8886,-733,0.5114748,0.851280277568133,98,-109 +111,-112,5021,538,5260,4533,0.030995976,0.681805979439128,146,13 +126,-96,6243,-719,1471,2345,0.9928639,0.00448100003469265,38,39 +9,-69,5106,503,5346,-7811,0.71314204,0.45804982473662137,195,48 +169,-105,4279,-866,1316,3246,0.43948078,0.3898902321517582,85,63 +222,-38,8612,-715,5462,7086,0.86776793,0.09235158602446425,231,-122 +113,-27,285,-525,8973,-7459,0.509312,0.49411749245843783,195,-70 +202,-10,6229,-706,3263,-7987,0.24268277,0.33755039495059036,26,56 +231,3,8888,-809,1832,-8992,0.30264434,0.5886949562900695,248,-12 +143,19,8877,-365,895,3608,0.8098223,0.43696155644657664,54,6 +194,16,7016,271,5926,691,0.20363607,0.08586015769661126,91,-91 +203,6,7478,-48,4080,7893,0.35400498,0.5075647501701379,148,-112 +243,-39,5897,190,6983,3638,0.44667006,0.5915194083715929,192,42 +206,17,627,-724,8904,5339,0.19689271,0.020487212149667644,186,4 +26,115,832,-598,3432,-4497,0.11278163,0.7975089132286959,196,-90 +98,-12,2921,-781,6526,7060,0.70328283,0.8557264646544915,51,37 +194,-18,9400,267,793,5387,0.85740477,0.8160706597795186,53,97 +5,63,9881,-805,3329,-424,0.12856853,0.5382006420229911,79,18 +186,30,9060,-622,3179,-7644,0.45370936,0.2080559916150384,76,32 +229,1,4228,-779,9688,-6411,0.84370077,0.3572510308972974,151,73 +209,-74,7383,965,4285,-3360,0.2727079,0.9320994963304401,215,46 +92,85,4025,-624,8548,-937,0.1430207,0.5959343442869012,145,-102 +159,3,6721,-226,5351,2977,0.1922379,0.9516119307813505,152,-114 +114,-9,5324,-948,140,9249,0.55591506,0.7418168061579014,131,95 +231,13,8246,232,1038,3245,0.4644002,0.38301951052293803,128,-111 +63,74,6813,-989,4594,-9472,0.8868855,0.14255077683235984,73,21 +102,72,3174,386,6280,-2073,0.5918702,0.7484603390804969,153,58 +116,-66,2781,-590,882,-5283,0.9065233,0.4900171382770514,145,-26 +170,-23,27,-359,8115,-2783,0.48276094,0.7568647004268102,161,16 +82,-76,9049,104,4938,-8019,0.42442733,0.4054416324228859,146,-15 +137,-69,8471,-194,738,-2048,0.9825156,0.9754556253819716,213,-6 +68,-49,933,369,6427,-7440,0.6419611,0.8423874458555876,220,-34 +71,-57,8040,592,4691,2965,0.4420772,0.14657144959008517,29,79 +160,120,9232,-850,9331,-2248,0.7871239,0.6249059581204505,159,-13 +177,-29,659,-33,6159,9444,0.7788533,0.8396359533275131,69,119 +107,113,7092,-505,7373,915,0.18254468,0.013346954455724869,194,78 +179,-90,4266,135,643,-7684,0.9545259,0.42004017298806806,138,7 +140,80,1518,125,4908,2177,0.16477706,0.428602536644232,250,9 +253,-101,5077,486,5992,8422,0.79558235,0.7406553087038695,242,14 +14,125,368,-480,5985,-8743,0.60513145,0.09362203238327826,34,-105 +186,52,4705,-756,5925,-9179,0.55707365,0.8300298775367202,219,-120 +29,-93,8891,-249,7921,8986,0.12605393,0.5313432652584172,136,-38 +10,40,4218,654,8787,5354,0.73502207,0.9315447745057547,27,61 +105,-124,4427,-745,4653,-2644,0.30494243,0.1462644632586677,134,36 +253,35,1337,163,545,98,0.1918209,0.855548359055591,108,32 +212,-66,5989,-358,6374,-9473,0.24008575,0.4627752838105317,53,-47 +86,112,5029,-481,8661,5230,0.33153024,0.9700279701006159,44,-87 +80,114,6230,-738,6384,545,0.83623755,0.9320175598176051,66,-101 +124,81,2960,-200,4249,-827,0.6855987,0.6750047594386782,127,-73 +226,-94,4836,-194,291,-5899,0.95212454,0.5536378434948156,69,-37 +195,-108,4156,21,5609,9725,0.4697026,0.4978770649299966,26,-30 +18,17,6315,567,494,-3866,0.28220278,0.10848225141313128,150,18 +149,25,960,592,232,1561,0.5251332,0.11686501515845982,196,-36 +208,-122,9816,-793,9656,-9248,0.3529781,0.6853331882399039,233,5 +3,-29,274,-610,2688,-4564,0.90734076,0.9853165607729131,0,11 +16,-68,9985,-712,1822,5510,0.23222311,0.31567893026671756,23,-63 +7,-109,8239,-556,6442,9266,0.30610391,0.2780128512153278,28,110 +104,-95,1479,270,33,-9363,0.7876541,0.3482311818519148,76,123 +138,73,1464,391,3578,2057,0.21675517,0.1033370015064854,146,-89 +197,-93,3705,-748,7429,1326,0.29187182,0.4248593577070049,235,-121 +54,-10,9008,630,3960,7857,0.7387029,0.720397383401499,212,51 +59,106,5820,-914,3961,4535,0.6187124,0.062200062869832595,250,-3 +138,47,3578,-76,5773,-663,0.96535313,0.18771659337689006,17,97 +223,-31,9020,503,6684,-8629,0.97642636,0.4566440540767457,158,-61 +103,48,9005,314,8332,8986,0.61826515,0.8761158602639904,164,-68 +237,111,7484,-304,2179,-1966,0.40703622,0.020501466560915782,242,16 +101,-50,2939,-975,2667,4911,0.4943187,0.48374235632800533,238,117 +198,79,5594,-941,7626,-9149,0.7375954,0.8081294006548257,142,-90 +155,63,6435,324,448,-3638,0.42949343,0.5980243708949529,141,-75 +57,-61,6422,-820,6405,-4258,0.89156926,0.9710210658225311,185,75 +249,75,3707,-394,2794,-5261,0.59606886,0.37131865119612817,250,-119 +203,-65,7865,828,2121,1277,0.7255104,0.5625975066748826,206,88 +233,-104,9988,346,1724,-2654,0.45469627,0.6451644311934689,129,36 +11,20,4274,601,64,1286,0.75742894,0.7084037216412503,5,-93 +213,-89,8421,-514,8197,-5555,0.3703185,0.02348481959524773,89,-118 +118,68,4996,-46,4430,-4641,0.20065172,0.6569559351611883,20,-91 +152,60,8204,-256,5818,-5761,0.99597985,0.0022513649909609024,35,-46 +108,15,6040,-355,3634,-1579,0.61953855,0.4887609994189648,122,119 +208,92,1575,-633,4456,-4237,0.40048835,0.23162322921476108,124,-96 +149,70,2720,198,2507,-7772,0.7501268,0.9804292840815554,144,-117 +196,-74,4807,830,4234,-9624,0.958742,0.5990039811207957,5,127 +245,54,8253,281,8791,7939,0.24006222,0.06053065804279967,101,43 +143,109,3154,-748,4964,5275,0.0089217145,0.9029979202026839,117,34 +52,107,5480,-276,6323,3249,0.5670589,0.7429287245811911,9,109 +148,-74,9180,947,1088,-6226,0.5842126,0.6457374368669877,60,-60 +119,77,3783,-284,4856,6911,0.09045854,0.0328246244471323,9,42 +188,92,5532,-66,2288,-9605,0.86758286,0.09078635873500562,127,100 +100,63,4928,-760,7891,-894,0.065559156,0.7081263575947863,96,50 +204,103,2255,-634,9810,-8296,0.5561468,0.3565243032803713,179,69 +151,74,2120,-930,294,3552,0.31584466,0.2331230638630175,7,-46 +126,-93,5426,86,6474,2910,0.42016467,0.5195582273525517,165,111 +80,-106,2308,107,5050,9702,0.8112454,0.6905657981501057,148,122 +125,-47,1699,-350,1329,9061,0.49807405,0.4844515534383862,203,-118 +61,127,6585,-853,995,-8307,0.11609436,0.17015610489381716,212,-31 +213,-63,9240,-242,7210,6049,0.39835948,0.22857479598471853,98,-71 +70,-10,6621,140,209,9567,0.20875598,0.5653644841647973,160,-32 +53,-25,6653,-113,631,-1036,0.8517091,0.3950623062206837,151,-76 +196,86,962,583,5,7462,0.22636536,0.5805315177552492,75,-116 +222,11,122,-151,8175,-2864,0.072153755,0.33215392459992144,180,-32 +129,57,9530,-917,6850,-4561,0.3932593,0.3476833236913556,57,-77 +164,-39,5351,691,1606,-665,0.22777905,0.653687353462844,90,-41 +35,-20,4929,-241,2091,5648,0.46021,0.2103577394005426,181,97 +106,90,5311,563,3959,9973,0.91999286,0.9306011700764755,249,-20 +221,1,3319,937,821,1170,0.9123631,0.9661343236415945,254,-82 +57,80,8646,140,2474,-8194,0.7186352,0.11288897600956682,75,56 +54,-70,9371,560,9918,422,0.115035154,0.40738055861176947,249,105 +206,116,1500,930,6479,-2,0.70489615,0.530499134161209,84,77 +254,-66,4741,-504,6281,3207,0.34755763,0.026308560481242305,131,65 +52,-116,6298,458,1862,-7506,0.18669711,0.23780258419888267,103,-69 +186,-103,1266,257,5956,312,0.8470686,0.48127604025130555,209,104 +216,35,3197,407,2815,6794,0.009859419,0.8067747207816371,252,26 +242,-125,46,-807,508,3097,0.74564064,0.36165742077589347,29,48 +173,-61,4508,-261,8681,-8905,0.07838161,0.973639463679807,244,-86 +162,-100,91,945,70,5238,0.7497941,0.6272373480092353,31,51 +26,79,3415,-215,493,-8918,0.66299444,0.7670002528395681,130,-37 +227,28,2880,737,4064,1949,0.6984911,0.34001954027472703,130,-4 +140,20,795,-126,9793,-4072,0.8095185,0.37640608652286467,212,-84 +74,78,375,-768,1861,41,0.92739886,0.2861627620155204,243,43 +129,-110,7963,-538,2428,-8495,0.12771292,0.09996561117665681,52,36 +52,-115,7378,845,1954,5977,0.32477102,0.20252255497186322,143,41 +212,-14,785,-897,5666,3412,0.38851732,0.9586853754301856,239,-125 +62,-51,7295,-238,1785,-2707,0.14697476,0.3170238030461162,216,56 +228,-101,8348,633,5733,299,0.24772856,0.20569761736740533,208,-62 +41,107,8842,-727,8721,9243,0.048227176,0.4041233022230516,167,-41 +15,26,8229,-237,1802,-4528,0.504234,0.8192468584923034,2,93 +71,63,2801,630,441,9428,0.96334517,0.7825218444071776,12,-108 +94,100,5538,-413,5669,745,0.14320867,0.22432906161677313,27,89 +36,-8,5783,-772,5172,-3542,0.8353628,0.26900805441338493,10,70 +48,7,3369,-915,8612,-5150,0.6956063,0.09124731043664269,156,-2 +84,17,9827,-739,7953,5767,0.3621803,0.30948789228622,178,9 +78,-46,7818,-776,1658,-5647,0.3604175,0.4174359178635655,168,-36 +93,-25,9300,863,2516,-6580,0.9430205,0.6459355401419636,158,-56 +175,-65,1793,-829,4539,-3580,0.46957827,0.9905216930310914,127,-10 +229,23,9914,358,2585,2698,0.0010360706,0.426016587190029,141,122 +212,105,6766,537,5511,-850,0.65569466,0.5376961350683968,194,-13 +194,22,8944,141,2657,5651,0.7796019,0.978663442655814,194,-56 +226,-40,4154,-563,124,-8924,0.9540252,0.33365906535201817,184,127 +192,119,5297,-46,1078,5180,0.65881324,0.000996332510714515,225,-14 +108,-49,1150,-554,4120,-274,0.3626766,0.2642857024058576,250,107 +60,112,2752,311,4706,8419,0.39529163,0.14218487326166174,77,29 +242,-16,4242,-107,8198,9762,0.42699453,0.319468336391172,86,-25 +191,119,1860,191,5207,6346,0.58810794,0.44684892371455986,122,40 +210,112,9326,-536,7689,-1276,0.55063856,0.5721396583561686,179,-44 +197,92,4042,639,1417,9560,0.20279588,0.3077279586684728,179,-84 +29,83,8557,13,9571,5210,0.8959824,0.21560639991980401,249,-45 +51,-69,5339,-345,974,-5620,0.8393893,0.6683846386444905,143,-116 +215,-109,1343,-538,8730,3865,0.8549025,0.8848702541885506,90,-74 +112,-1,1214,514,9173,-3473,0.54059017,0.021784603668224545,188,-19 +142,81,8059,383,5137,-5850,0.9562446,0.2861370545235987,176,93 +176,-47,2399,581,3448,-3294,0.11205351,0.20788290321719405,90,-109 +164,-110,9758,-350,5888,-9070,0.28884354,0.5046304328182684,27,-35 +151,75,720,-222,6281,6144,0.39981025,0.2567856509544405,206,-109 +176,2,2050,547,1953,-3860,0.78007567,0.3718843591911637,221,51 +132,-7,3296,-957,5611,-9500,0.9398271,0.6437542254548347,188,50 +18,-22,2186,608,5579,9332,0.5561215,0.30799433273859134,253,24 +245,3,9327,-105,4404,9579,0.27153492,0.5259776031002164,142,72 +128,93,9344,-119,4694,-504,0.77115405,0.4621782730292555,145,-69 +58,-38,8999,467,3819,-8139,0.6938719,0.43444774675313025,24,-49 +84,-1,5566,-55,8525,1853,0.052212164,0.1810160525395621,12,-15 +165,10,9941,473,2904,6280,0.19559929,0.1761292344132288,177,-19 +103,72,9807,-218,1319,939,0.4528472,0.4773638581096957,246,11 +46,-70,4937,-272,7818,-8416,0.4765789,0.06256519771634539,194,-18 +129,7,1551,178,6858,8062,0.092404746,0.6440248389907725,176,91 +112,98,5239,733,7235,9800,0.06587752,0.7671706098862288,18,125 +8,65,626,89,721,9923,0.9301452,0.4068553508705831,46,-37 +222,49,7976,682,9217,2808,0.6651399,0.008076128637859892,10,38 +41,45,1907,-464,5371,5862,0.66812307,0.5033683917807024,27,38 +188,118,5734,-799,8222,9914,0.1348112,0.006635300472096595,194,-118 +225,61,913,-215,610,-5988,0.47461623,0.14334021949945253,161,120 +151,87,7318,793,7278,-103,0.79847664,0.6863619403152351,169,123 +149,-41,4039,-662,8644,-837,0.11439147,0.3335403537247539,45,1 +11,90,7591,396,7746,6021,0.6181762,0.22041179764793917,185,8 +46,-62,318,-204,8029,992,0.87317073,0.5774457809870189,152,80 +234,124,7111,-381,4157,7757,0.8629895,0.8431090068289852,49,-26 +173,-110,3434,794,5699,-6685,0.6599288,0.006260174489092218,164,-126 +150,-112,9343,-683,601,-4740,0.6361613,0.26007300214894624,163,-107 +165,54,6168,-63,4524,2106,0.10124723,0.03242917886081653,239,-94 +208,101,8306,455,5775,-8688,0.26331043,0.06929854686826997,242,64 +189,97,8794,466,7829,-7758,0.009536836,0.4605092992544745,179,-35 +145,-54,7175,681,5778,-952,0.6997116,0.15696235191400942,45,-80 +252,-6,5722,-768,6287,3260,0.71212184,0.7122507779355989,90,-98 +47,69,6569,-128,8753,4848,0.47539726,0.6974420017753635,106,94 +103,108,4180,182,6192,-9412,0.9354268,0.37673340363159247,115,-79 +142,-53,506,766,7340,-267,0.9059018,0.2031458840759076,35,-57 +58,-54,9874,70,4609,-9470,0.86980337,0.7303227142990615,234,-46 +63,34,7407,-929,6213,-8196,0.7299324,0.3177848255800607,199,57 +74,20,4809,-62,4888,-7093,0.10156781,0.09884190588446373,35,-53 +108,71,1377,552,9973,-3297,0.02214298,0.441467509525711,109,15 +229,1,3381,64,9041,-325,0.45501915,0.1157132504177818,60,-70 +232,115,2175,216,7319,9974,0.36204958,0.7008392299111899,173,-109 +78,-63,7691,888,5683,5869,0.6673367,0.23570350038025323,241,-64 +246,-28,3585,-613,3332,-7722,0.5585669,0.5672019263900571,27,-118 +94,-77,3977,889,8621,7487,0.028852351,0.45542973034301415,223,28 +181,51,265,-734,6141,2126,0.6408606,0.8677598349791151,103,-88 +6,-106,530,-113,8650,-3282,0.51909757,0.9185959289454969,154,100 +42,102,4220,-768,2154,1999,0.99905276,0.44288426582545826,102,-99 +57,96,3274,63,3340,-9799,0.105777755,0.6880261388060428,202,9 +201,56,7807,460,3578,959,0.13685258,0.7313698685719422,160,-50 +247,108,3024,-428,5280,1179,0.48549908,0.34208395201244135,137,-68 +104,119,5340,309,6003,-5207,0.73982143,0.2789203009245158,47,61 +38,100,3133,895,2240,-207,0.95311856,0.4763780182590237,206,-30 +127,-96,7686,900,6273,-2323,0.7887642,0.9636980309875932,158,42 +60,95,8105,-498,6189,-279,0.09211435,0.6895003112308339,254,-37 +53,-79,720,601,8984,-7557,0.03328776,0.38714617648675353,39,90 +148,101,887,-500,666,9171,0.9359988,0.42059157745467235,134,-43 +182,-88,6136,-210,4327,-7985,0.442414,0.7723498011403294,190,-109 +0,-108,302,547,1631,3851,0.8743039,0.16581243797322265,236,76 +62,-2,7566,974,5904,-3913,0.98290974,0.8994016309999401,200,5 +227,122,3078,-317,9420,7844,0.8588829,0.2642335194520873,124,60 +50,-45,835,765,7934,-5220,0.7937192,0.7913929964956798,10,23 +146,93,1054,-72,2522,-8512,0.7869619,0.5791959951985417,32,61 +249,-53,2239,-754,9019,-9517,0.62618816,0.7152057654969722,190,53 +122,84,508,-534,7119,-2041,0.48632938,0.5639511594097462,193,-57 +34,-29,9977,991,1165,-4231,0.25605792,0.08573278107563431,125,-82 +57,-84,3504,-240,2531,-8433,0.3068936,0.8712330449478326,117,-34 +19,-40,759,-268,3373,2358,0.32669085,0.26289643848664823,119,-1 +120,54,5345,207,3393,5582,0.20927475,0.7006227833359849,85,49 +152,69,8258,471,5083,127,0.9087119,0.7328062776048149,86,-13 +65,67,8518,559,6219,3484,0.11439653,0.7482817916403712,15,114 +118,-116,4153,788,2767,1842,0.38367966,0.9554688594060051,241,22 +117,26,7603,-731,3538,-2347,0.7203055,0.8841094725576265,127,-55 +207,-40,6112,-163,780,922,0.89470565,0.16044283582973562,8,56 +118,1,5895,-703,9031,-9842,0.92047286,0.1599925545174653,103,4 +127,6,7290,-856,5929,-9965,0.28029445,0.2717052552469579,48,-4 +1,-59,525,216,3216,-5641,0.96868587,0.059106489501493886,98,23 +171,102,639,66,3994,-2664,0.53047734,0.9279074638196484,166,-114 +57,58,8221,-297,5677,8759,0.9088563,0.06628467722575582,103,63 +32,118,7427,916,4410,8902,0.20872322,0.23851007431386773,10,11 +83,-53,4917,937,1264,-7232,0.9818382,0.15247277625380218,72,78 +95,-94,6760,-878,4062,9406,0.4698735,0.7149214881038684,76,-66 +208,80,2708,242,9187,6139,0.6348908,0.09968831852129711,17,90 +85,-65,7990,574,8948,9957,0.3819776,0.5749936411713055,79,-51 +190,-118,4002,-297,1564,2947,0.11180455,0.3807269672936542,183,-77 +20,5,1781,498,9284,9334,0.5129638,0.5688847105277695,5,-63 +16,77,7961,-901,2984,5297,0.3151628,0.9573698359549686,150,-111 +53,-97,973,382,9601,-2989,0.1386372,0.6147720448946071,117,-9 +159,-60,4971,-859,2333,-5258,0.72438574,0.5181931400588183,105,50 +107,49,7481,353,2338,8151,0.3534558,0.908270659933179,114,-76 +244,83,9943,381,8294,-1430,0.072708935,0.32493436620065463,248,-8 +214,-81,5954,808,9838,-1431,0.75337446,0.8422711496343955,251,115 +225,5,7764,-584,7533,2064,0.5836893,0.3487981496238638,12,32 +146,-116,5092,189,3386,-4384,0.8912944,0.924333715937792,131,96 +246,78,4027,-829,1731,5204,0.7087481,0.33355828550620625,107,90 +123,27,5080,-921,8417,7401,0.66336364,0.47886672092771854,143,-65 +48,-83,8913,-94,8015,-9014,0.65286994,0.9907102979204924,151,-10 +63,31,3878,-889,8189,6181,0.43130437,0.4278562730914105,219,93 +176,23,7365,642,4886,6453,0.26408997,0.8686076757160837,86,-33 +78,-36,6575,-514,162,-25,0.8901921,0.3632825851816436,178,6 +7,81,3059,518,8441,-1579,0.48047575,0.07965496084871293,205,-49 +2,121,1881,-91,850,-8600,0.36532465,0.2518122135412113,51,63 +102,57,5392,-557,169,5470,0.042592112,0.24088059611768653,183,-22 +124,85,6714,-690,9327,100,0.29717413,0.07899426070677651,242,-58 +34,-111,1945,-743,2575,1560,0.8231638,0.7008249649150682,136,-48 +249,-113,916,223,8772,-885,0.6439618,0.6641241512931164,198,91 +167,51,8493,-533,277,-2265,0.2549173,0.7253350541598359,147,92 +237,122,1055,-356,9299,9226,0.66173416,0.9993978902007801,245,119 +177,-88,2296,-783,9063,4341,0.7444216,0.8456044389246419,27,37 +238,48,133,-163,789,-9726,0.43560925,0.04950608955367475,109,7 +58,56,8041,-572,8567,-7025,0.6067,0.6880809599528198,184,-3 +20,47,625,797,6651,-903,0.72908765,0.9821653094820115,187,80 +32,-82,2476,584,472,-5636,0.8195388,0.5416319170194364,95,-66 +177,-61,6097,493,1809,8089,0.77862966,0.05829861323168639,155,-63 +185,-102,7205,449,4929,634,0.89020324,0.6833162554102336,25,-98 +235,-96,1660,-831,2794,-725,0.976079,0.46755777143609123,214,-79 +182,52,6579,347,3359,-2338,0.5214117,0.3833900980913849,64,-57 +162,-30,5357,-985,3851,1034,0.78962255,0.4691086098468489,138,-80 +203,110,8850,586,6840,-4120,0.8127857,0.4654431112876287,55,117 +144,85,7506,237,1005,3611,0.8891194,0.23838976010891622,149,65 +105,35,3615,-157,6730,2472,0.026465047,0.7305113225782652,221,10 +73,-24,1688,-512,1409,-5883,0.31885782,0.6500274564254704,186,-41 +154,-74,5461,-848,4284,-3895,0.078522824,0.8561216723015526,77,63 +10,-27,8622,-550,9546,677,0.47169626,0.4870264725815907,104,-56 +54,106,382,-175,9083,-3631,0.3511216,0.7826497679082716,69,26 +115,-100,2228,655,6128,7608,0.89574313,0.2305983131831223,104,56 +161,36,4481,677,1306,-1256,0.083240874,0.08130530307245765,43,-44 +87,-72,4902,-233,1411,6112,0.5351221,0.02894557807548004,237,-120 +59,51,9158,-425,4095,4756,0.7398863,0.7763651816595714,121,-84 +245,-104,2412,279,6085,-5631,0.72762465,0.22224759712785458,189,-68 +62,121,9004,834,8267,5412,0.22152944,0.5630208420743912,31,28 +74,30,5782,-170,7667,3290,0.9099677,0.3156140229690717,178,66 +232,-54,3559,-511,4859,-4804,0.88565224,0.5332077505829576,145,-30 +32,-38,8134,945,4503,-2308,0.37412977,0.5816854163533642,100,-74 +130,123,8590,-408,6117,2518,0.17960414,0.9373064323964656,62,-5 +231,59,8335,-707,6199,2121,0.81074005,0.7917637716751151,152,-122 +187,-128,5057,83,4248,-2348,0.2648629,0.4158982816468445,0,-26 +254,65,771,551,1522,2011,0.5299568,0.8667068410394598,140,51 +194,-43,9878,-995,4927,3870,0.25930265,0.7803372985065917,112,-66 +196,-77,2261,357,9242,-6933,0.37644163,0.3401473487079364,163,-114 +72,-93,5644,192,1942,-5296,0.10929289,0.6653397963347863,28,-42 +22,72,3660,-570,8966,3346,0.934112,0.0960225835563967,137,5 +216,27,5277,-259,4165,-6741,0.2764922,0.22599679608160728,27,122 +30,18,5736,-258,5282,-695,0.87188405,0.5199244953236036,131,-80 +64,69,4735,-789,4034,-2175,0.44851753,0.9914777840572122,16,109 +89,-46,2953,593,4932,-9872,0.74582255,0.07378536629230015,1,-87 +117,-36,2987,764,211,7597,0.94127524,0.4054574195486885,155,31 +9,-93,4643,-239,6204,8838,0.6974973,0.6995856345810624,230,95 +184,-62,5864,-992,1790,-8994,0.8343986,0.5977980347834626,207,38 +136,95,8503,-842,994,-7474,0.6140574,0.8330692436473752,16,101 +14,-75,7794,-558,7179,-4159,0.7496414,0.6758498201492769,218,-99 +226,36,3019,-133,1227,-4543,0.04920448,0.9918244119614513,81,-114 +46,-42,6755,404,2577,-772,0.13672307,0.7844790576421891,187,-41 +172,-28,7801,635,4599,-8464,0.8312957,0.5884774731177791,193,107 +77,20,1367,316,4385,8637,0.70334744,0.6931083319893615,118,-21 +32,65,485,-255,6266,9170,0.94637406,0.028018141938426,163,-70 +8,-84,7555,785,2245,-8171,0.77178943,0.9564681377190757,218,29 +101,-9,9567,172,3434,9391,0.26182294,0.4097299880784071,41,-49 +70,118,9943,-437,1448,-6017,0.797847,0.9662103008019209,15,120 +227,-20,3504,-889,7368,4575,0.24660411,0.8809634896902111,107,-44 +133,98,1839,-846,2739,-6337,0.6283305,0.7503361682618662,53,38 +18,42,818,535,4897,4551,0.19069575,0.8814527191479716,175,119 +48,-42,3853,-613,8130,-6732,0.69948196,0.419554217647784,59,-113 +180,122,96,-180,5882,5764,0.99194145,0.17914880965959157,152,-10 +193,0,8940,83,4849,-9225,0.7720228,0.5829083211325814,82,-83 +216,-73,6427,-231,1535,-322,0.16553669,0.6382578643527951,20,-82 +164,-91,3656,283,6308,-7730,0.5948408,0.46424596955422603,63,33 +44,61,5305,-468,5909,539,0.18251231,0.2006969912921558,246,47 +101,60,4729,782,8893,4291,0.7412346,0.4032582188091881,198,-57 +210,-1,3109,155,1947,7985,0.95992655,0.415304679950262,6,-111 +153,-15,532,-203,4192,3724,0.45357385,0.8176845834604605,62,49 +48,15,2979,629,9454,-6402,0.59040564,0.7259725153104022,235,91 +29,-19,4225,991,7163,-9253,0.8451455,0.34483998061104637,168,-23 +40,6,4690,366,4410,4134,0.32322168,0.9070970799924551,211,108 +189,-55,9600,958,5508,-6266,0.053882103,0.8268306769471271,5,64 +247,-58,99,109,6969,336,0.5842724,0.261727471264104,238,-112 +169,104,6035,775,121,-7514,0.35877824,0.2060952715220915,228,-42 +33,-3,405,278,370,5278,0.5721922,0.7238523305332896,4,45 +164,0,98,-452,9832,-6913,0.87075675,0.24944008129539397,185,114 +183,-112,485,-94,6470,-3588,0.38539907,0.8334664747172054,245,6 +227,-30,2027,-82,4848,9069,0.84914035,0.7129682927284361,226,105 +104,21,1773,499,974,8824,0.43427405,0.09462923498120679,47,2 +237,61,7652,910,7498,2301,0.69658864,0.2070707587939653,9,110 +177,-63,2782,273,4585,-8069,0.1565542,0.8889684424171824,201,75 +251,19,5800,-336,1049,-7774,0.7088506,0.6224554395038597,58,62 +57,84,7971,-210,9530,-9976,0.7301661,0.09045085126690966,224,-21 +122,-95,8296,-575,7647,-391,0.6064761,0.8621032429045278,235,54 +221,-45,9396,74,3261,-8580,0.09520004,0.9820533977016531,7,-4 +64,-39,8559,-471,7561,1172,0.33570907,0.5845685419106239,182,-58 +149,-21,9865,852,4085,5801,0.40042892,0.5741632430049837,47,20 +209,75,1055,743,6830,-3743,0.09771469,0.011240166860528644,125,-85 +234,14,349,-22,6237,6511,0.66197264,0.6006597397093891,106,54 +122,90,8527,722,3217,-1420,0.12773106,0.9074808553392961,165,51 +27,-75,316,-253,9664,-7222,0.24615858,0.6619682215152259,41,-88 +101,-98,3989,-510,9974,-7643,0.77117175,0.11853431835539785,67,-75 +206,-95,8133,334,8014,6692,0.6890024,0.09413940685254563,144,11 +29,75,3781,-535,7828,4513,0.61737186,0.4630775661791684,4,89 +156,-128,3221,-888,2363,2281,0.934251,0.7092613426876336,153,70 +138,-84,4387,-595,2244,-6465,0.43075135,0.7360959146430157,166,-24 +10,26,3733,876,5446,2732,0.7033742,0.9830392906942708,74,-29 +58,-126,2320,-58,5830,-9948,0.76339674,0.04825868481079765,33,29 +66,0,3030,189,3745,762,0.23327248,0.5526918433638573,230,29 +92,-71,1797,-332,4060,9854,0.5221939,0.773505416980888,189,-83 +52,-29,809,-789,9441,1072,0.48853603,0.6436777638465271,118,12 +152,-98,8667,-461,6865,-7005,0.43519595,0.8155568126719547,160,-93 +112,122,4325,4,9816,2132,0.48591208,0.8350693996435217,113,-102 +157,-47,8019,40,17,-3088,0.57721937,0.8314862087848581,152,88 +65,92,1328,462,755,-6205,0.24278879,0.01239819386469676,100,-1 +36,-95,267,562,6100,-8004,0.8494087,0.8848816503219006,76,47 +179,-87,4871,113,1536,1904,0.91000926,0.30424891347890703,104,-35 diff --git a/evaluation/data_1000r_10c_NUMBER.csv.meta b/evaluation/data_1000r_10c_NUMBER.csv.meta new file mode 100644 index 000000000..82fdf0e86 --- /dev/null +++ b/evaluation/data_1000r_10c_NUMBER.csv.meta @@ -0,0 +1,46 @@ +{ + "numRows": 1000, + "numCols": 10, + "schema": [ + { + "label": "col_0_uint8", + "valueType": "ui8" + }, + { + "label": "col_1_int8", + "valueType": "si8" + }, + { + "label": "col_2_uint32", + "valueType": "ui32" + }, + { + "label": "col_3_int32", + "valueType": "si32" + }, + { + "label": "col_4_uint64", + "valueType": "ui64" + }, + { + "label": "col_5_int64", + "valueType": "si64" + }, + { + "label": "col_6_float32", + "valueType": "f32" + }, + { + "label": "col_7_float64", + "valueType": "f64" + }, + { + "label": "col_8_uint8", + "valueType": "ui8" + }, + { + "label": "col_9_int8", + "valueType": "si8" + } + ] +} \ No newline at end of file diff --git a/evaluation/eval-file-sizes.py b/evaluation/eval-file-sizes.py new file mode 100644 index 000000000..21ce15a39 --- /dev/null +++ b/evaluation/eval-file-sizes.py @@ -0,0 +1,132 @@ +import os +import glob +import pandas as pd +import re +import matplotlib.pyplot as plt + +# Folder containing the CSV files. +data_dir = "data" + +# Get all CSV file paths in the data directory. +csv_paths = glob.glob(os.path.join(data_dir, "*.csv")) + +results = [] + +# Helper function to extract a data subtype from the filename. +# Searches for keywords like FLOAT, STR, MIXED (case insensitive). +def extract_subtype(filename): + subtype = "unknown" + for candidate in ['float', 'str', 'mixed', 'number', 'rep', 'fixedstr', 'strdiff']: + if re.search(candidate, filename, re.IGNORECASE): + subtype = candidate + break + return subtype + +for csv_file in csv_paths: + # Get CSV file size in bytes. + csv_size = os.path.getsize(csv_file) + + # The corresponding dbdf file is assumed to be named as the CSV plus a ".dbdf" extension. + dbdf_file = csv_file + ".dbdf" + if os.path.exists(dbdf_file): + dbdf_size = os.path.getsize(dbdf_file) + else: + dbdf_size = None + + # Determine the main data type from the file name. + base = os.path.basename(csv_file) + main_type = "matrix" if base.startswith("matrix_") else "frame" + + # Extract data subtype (e.g., float, str, mixed) + subtype = extract_subtype(base) + + # Compute ratio, if possible (in percentage). + ratio = (dbdf_size / csv_size * 100) if dbdf_size is not None else None + + results.append({ + "CSVFile": base, + "MainDataType": main_type, + "DataSubtype": subtype, + "CSVSize (bytes)": csv_size, + "dbdfSize (bytes)": dbdf_size, + "Ratio (%)": ratio + }) + +# Build a DataFrame from the results. +df = pd.DataFrame(results) + +# Print the table. +print("Detailed file sizes and ratio:") +print(df) + +# Compute the average ratio per MainDataType. +avg_main = df.groupby("MainDataType")["Ratio (%)"].mean().reset_index() +print("\nAverage percentage of dbdf size relative to CSV size by main data type:") +print(avg_main) + +# Compute the average ratio per DataSubtype. +avg_subtype = df.groupby("DataSubtype")["Ratio (%)"].mean().reset_index() +print("\nAverage percentage of dbdf size relative to CSV size by data subtype:") +print(avg_subtype) + +# Optionally, save the results table to a CSV file. +df.to_csv("file_size_comparison.csv", index=False) +avg_main.to_csv("average_ratio_by_main_type.csv", index=False) +avg_subtype.to_csv("average_ratio_by_subtype.csv", index=False) + +# Combine the computed averages with a reference 100% value. +baseline = pd.DataFrame({"Type": ["CSV"], "Ratio (%)": [100], "Group": ["baseline"]}) + +# avg_main has two rows: one for frame and one for matrix. +avg_main['Group'] = avg_main["MainDataType"] # "frame" or "matrix" +avg_main = avg_main.rename(columns={"MainDataType": "Type"}) + +# Compute average ratios by data subtype separately for frame and matrix. +avg_subtype_frame = df[df["MainDataType"] == "frame"].groupby("DataSubtype")["Ratio (%)"].mean().reset_index() +avg_subtype_frame["Group"] = "frame" +avg_subtype_matrix = df[df["MainDataType"] == "matrix"].groupby("DataSubtype")["Ratio (%)"].mean().reset_index() +avg_subtype_matrix["Group"] = "matrix" +avg_subtype_frame = avg_subtype_frame.rename(columns={"DataSubtype": "Type"}) +avg_subtype_matrix = avg_subtype_matrix.rename(columns={"DataSubtype": "Type"}) + +# Concatenate all results. +bar_data = pd.concat([baseline, avg_main, avg_subtype_frame, avg_subtype_matrix], ignore_index=True) + +# Now order the bars: +# We'll place baseline first, then frame: first the main frame (i.e. Type=="frame") then its subtype rows sorted alphabetically, +# then matrix: first the main matrix value then its subtype rows sorted alphabetically. +#frame_main = bar_data[(bar_data["Group"]=="frame") & (bar_data["Type"]=="frame")] +frame_sub = bar_data[(bar_data["Group"]=="frame") & (bar_data["Type"]!="frame")].sort_values("Type") +#matrix_main = bar_data[(bar_data["Group"]=="matrix") & (bar_data["Type"]=="matrix")] +matrix_sub = bar_data[(bar_data["Group"]=="matrix") & (bar_data["Type"]!="matrix")].sort_values("Type") + +ordered_bar_data = pd.concat([baseline, frame_sub, matrix_sub], ignore_index=True) + +# Assign colors: baseline in black, frame group in blue, matrix group in green. +def assign_color(row): + if row["Group"] == "baseline": + return "#d62728" # baseline normal red + elif row["Group"] == "frame": + if row["Type"] == "frame": + return "#1f77b4" # normal blue for main frame + else: + return "#aec7e8" # light blue for frame subtypes + elif row["Group"] == "matrix": + if row["Type"] == "matrix": + return "#2ca02c" # normal green for main matrix + else: + return "#98df8a" # light green for matrix subtypes + else: + return "gray" + +ordered_bar_data["Color"] = ordered_bar_data.apply(assign_color, axis=1) + +# Create a bar chart. +plt.figure(figsize=(12,6)) +bars = plt.bar(ordered_bar_data["Type"], ordered_bar_data["Ratio (%)"], color=ordered_bar_data["Color"]) +plt.xlabel("Data Type / Category") +plt.ylabel("Average dbdf/CSV Size Ratio (%)") +plt.title("Comparison: 100% CSV vs. Average dbdf Ratios by Data Type/Subtype") +plt.xticks(rotation=45) +plt.tight_layout() +plt.savefig("fig/avg_ratio_bar_chart.png") \ No newline at end of file diff --git a/evaluation/evalReadFrame.daphne b/evaluation/evalReadFrame.daphne new file mode 100644 index 000000000..b1a0658dc --- /dev/null +++ b/evaluation/evalReadFrame.daphne @@ -0,0 +1,2 @@ +#./bin/daphne --timing --second-read-opt test/api/cli/io/evalReadFrame.daphne +readFrame("evaluation/data_1000r_10c_NUMBER.csv"); \ No newline at end of file diff --git a/evaluation/evalReadFrame2.daphne b/evaluation/evalReadFrame2.daphne new file mode 100644 index 000000000..77d818102 --- /dev/null +++ b/evaluation/evalReadFrame2.daphne @@ -0,0 +1 @@ +readFrame("evaluation/data_1000r_1000c_NUMBER.csv"); \ No newline at end of file diff --git a/evaluation/fig/avg_ratio_bar_chart.png b/evaluation/fig/avg_ratio_bar_chart.png new file mode 100644 index 000000000..55e2ac795 Binary files /dev/null and b/evaluation/fig/avg_ratio_bar_chart.png differ diff --git a/evaluation/fig/create_read_breakdown.png b/evaluation/fig/create_read_breakdown.png new file mode 100644 index 000000000..0472fb130 Binary files /dev/null and b/evaluation/fig/create_read_breakdown.png differ diff --git a/evaluation/fig/opt_read_breakdown.png b/evaluation/fig/opt_read_breakdown.png new file mode 100644 index 000000000..32da0996f Binary files /dev/null and b/evaluation/fig/opt_read_breakdown.png differ diff --git a/evaluation/fig/overall_read_time.png b/evaluation/fig/overall_read_time.png new file mode 100644 index 000000000..29258c655 Binary files /dev/null and b/evaluation/fig/overall_read_time.png differ diff --git a/evaluation/fig/overall_read_time_frame_mixed.png b/evaluation/fig/overall_read_time_frame_mixed.png new file mode 100644 index 000000000..3aaba2266 Binary files /dev/null and b/evaluation/fig/overall_read_time_frame_mixed.png differ diff --git a/evaluation/fig/overall_read_time_frame_number.png b/evaluation/fig/overall_read_time_frame_number.png new file mode 100644 index 000000000..26739355e Binary files /dev/null and b/evaluation/fig/overall_read_time_frame_number.png differ diff --git a/evaluation/fig/overall_read_time_matrix_float.png b/evaluation/fig/overall_read_time_matrix_float.png new file mode 100644 index 000000000..9ffae2ec3 Binary files /dev/null and b/evaluation/fig/overall_read_time_matrix_float.png differ diff --git a/evaluation/fig/overall_read_time_matrix_rep.png b/evaluation/fig/overall_read_time_matrix_rep.png new file mode 100644 index 000000000..5717f1cd8 Binary files /dev/null and b/evaluation/fig/overall_read_time_matrix_rep.png differ diff --git a/evaluation/fig/overall_read_time_matrix_str.png b/evaluation/fig/overall_read_time_matrix_str.png new file mode 100644 index 000000000..93dd9dc91 Binary files /dev/null and b/evaluation/fig/overall_read_time_matrix_str.png differ diff --git a/evaluation/run-experiments.sh b/evaluation/run-experiments.sh new file mode 100644 index 000000000..a2b4cb717 --- /dev/null +++ b/evaluation/run-experiments.sh @@ -0,0 +1,119 @@ +#!/usr/bin/bash +#run file in evaluation dir via ./run-experiments.sh +CSV_DIR="data" +LOG_DIR="./results" + +REPS=6 +DAPHNE="../bin/daphne" + +# Build a corresponding Daphne script if not yet present. +for csvfile in "$CSV_DIR"/*.csv; do + filename=$(basename "$csvfile") + + # Determine if the CSV is a matrix or a frame based on its name. + if [[ $filename == matrix_* ]]; then + fileType="matrix" + else + fileType="frame" + fi + # Build a corresponding Daphne script if not yet present. + daphneFile="${CSV_DIR}/${filename%.csv}.daphne" + if [ ! -f "$daphneFile" ]; then + if [ "$fileType" == "matrix" ]; then + echo "readMatrix(\"${csvfile}\");" > "$daphneFile" + else + echo "readFrame(\"${csvfile}\");" > "$daphneFile" + fi + fi + + # Choose proper log file names. + logNormal="${LOG_DIR}/evaluation_results_${filename}_normal.csv" + logCreate="${LOG_DIR}/evaluation_results_${filename}_create.csv" + logOpt="${LOG_DIR}/evaluation_results_${filename}_opt.csv" + + # Write headers if these files do not exist. + # Header: CSVFile,Experiment,Trial,ReadTime,WriteTime,StartupSeconds,ParsingSeconds,CompilationSeconds,ExecutionSeconds,TotalSeconds + for logfile in "$logNormal" "$logCreate" "$logOpt"; do + if [ ! -f "$logfile" ]; then + echo "CSVFile,Experiment,Trial,ReadTime,WriteTime,StartupSeconds,ParsingSeconds,CompilationSeconds,ExecutionSeconds,TotalSeconds" > "$logfile" + fi + done + + echo "Running experiments for $filename ..." + + ########################### + # Experiment 1: Normal Read + ########################### + for i in $(seq 1 $((REPS+1))); do + if [ "$filename" == "evaluation_results_frame_1000000r_1000c_MIXED.csv" ]; then + continue + fi + output=$(stdbuf -oL $DAPHNE --timing "$daphneFile" 2>&1) + # Discard the first run (warm-up). + if [ $i -eq 1 ]; then continue; fi + # Use a sed pattern that captures floating‐point numbers. + read_time=$(echo "$output" | head -n1 | sed 's/[^0-9.]*\([0-9.]*\).*/\1/') + json_line=$(echo "$output" | tail -n1) + startup=$(echo "$json_line" | grep -oP '"startup_seconds":\s*\K[0-9.]+') + parsing=$(echo "$json_line" | grep -oP '"parsing_seconds":\s*\K[0-9.]+') + compilation=$(echo "$json_line" | grep -oP '"compilation_seconds":\s*\K[0-9.]+') + execution=$(echo "$json_line" | grep -oP '"execution_seconds":\s*\K[0-9.]+') + total=$(echo "$json_line" | grep -oP '"total_seconds":\s*\K[0-9.]+') + echo "$filename,normal,$i,$read_time,,,${startup},${parsing},${compilation},${execution},${total}" >> "$logNormal" + done + + ########################### + # Experiment 2: First Read (Create Posmap) + ########################### + for i in $(seq 1 $((REPS+1))); do + posmapFile="${csvfile}.posmap" + [ -f "$posmapFile" ] && rm -f "$posmapFile" + # Always use --second-read-opt for posmap creation. + output=$(stdbuf -oL $DAPHNE --timing --second-read-opt "$daphneFile" 2>&1) + # Discard first run. + if [ $i -eq 1 ]; then continue; fi + # Extract overall read time from READ_TYPE=first and write posmap time from OPERATION=write_posmap. + read_line=$(echo "$output" | grep "READ_TYPE=first," | head -n1) + read_time=$(echo "$read_line" | sed 's/.*READ_TIME=\([0-9eE\.-]*\).*/\1/') + [ -z "$read_time" ] && read_time="0" + write_line=$(echo "$output" | grep "OPERATION=write_bin," | head -n1) + write_time=$(echo "$write_line" | sed 's/.*WRITE_TIME=\([0-9eE\.-]*\).*/\1/') + [ -z "$write_time" ] && write_time="0" + json_line=$(echo "$output" | grep "{" | head -n1) + startup=$(echo "$json_line" | grep -oP '"startup_seconds":\s*\K[0-9.]+') + parsing=$(echo "$json_line" | grep -oP '"parsing_seconds":\s*\K[0-9.]+') + compilation=$(echo "$json_line" | grep -oP '"compilation_seconds":\s*\K[0-9.]+') + execution=$(echo "$json_line" | grep -oP '"execution_seconds":\s*\K[0-9.]+') + total=$(echo "$json_line" | grep -oP '"total_seconds":\s*\K[0-9.]+') + # For first read, we report overall ReadTime and WriteTime; PosmapReadTime remains empty. + echo "$filename,create,$i,$read_time,$write_time,,${startup},${parsing},${compilation},${execution},${total}" >> "$logCreate" + # Remove the posmap file before the next iteration. + posmapFile="${csvfile}.posmap" + [ -f "$posmapFile" ] && rm -f "$posmapFile" + done + + ########################### + # Experiment 3: Second Read (Optimized Read using posmap) + ########################### + # First, create the posmap. + posmapFile="${csvfile}.posmap" + $DAPHNE --timing --second-read-opt "$daphneFile" > /dev/null + # Reuse the posmap for each trial. + for i in $(seq 1 $((REPS+1))); do + output=$(stdbuf -oL $DAPHNE --timing --second-read-opt "$daphneFile" 2>&1) + if [ $i -eq 1 ]; then continue; fi + # Extract overall read time directly with grep -oP. + read_line=$(echo "$output" | grep "READ_TYPE=second," | head -n1) + read_time=$(echo "$read_line" | sed 's/.*READ_TIME=\([0-9eE\.-]*\).*/\1/') + [ -z "$read_time" ] && read_time="0" + json_line=$(echo "$output" | grep "{" | head -n1) + startup=$(echo "$json_line" | grep -oP '"startup_seconds":\s*\K[0-9.]+') + parsing=$(echo "$json_line" | grep -oP '"parsing_seconds":\s*\K[0-9.]+') + compilation=$(echo "$json_line" | grep -oP '"compilation_seconds":\s*\K[0-9.]+') + execution=$(echo "$json_line" | grep -oP '"execution_seconds":\s*\K[0-9.]+') + total=$(echo "$json_line" | grep -oP '"total_seconds":\s*\K[0-9.]+') + echo "$filename,opt,$i,$read_time,,${posmap_read_time},${startup},${parsing},${compilation},${execution},${total}" >> "$logOpt" + done + +done +echo "Experiments completed." \ No newline at end of file diff --git a/scripts/examples/extensions/myKernels/myKernels.cpp b/scripts/examples/extensions/myKernels/myKernels.cpp index a03bbc0b7..f9189eb5c 100644 --- a/scripts/examples/extensions/myKernels/myKernels.cpp +++ b/scripts/examples/extensions/myKernels/myKernels.cpp @@ -7,60 +7,43 @@ class DaphneContext; extern "C" { - // Custom sequential sum-kernel. - void mySumSeq( - float * res, - const DenseMatrix * arg, - DaphneContext * ctx - ) { - std::cerr << "hello from mySumSeq()" << std::endl; - const float * valuesArg = arg->getValues(); - *res = 0; - for(size_t r = 0; r < arg->getNumRows(); r++) { - for(size_t c = 0; c < arg->getNumCols(); c++) - *res += valuesArg[c]; - valuesArg += arg->getRowSkip(); - } +// Custom sequential sum-kernel. +void mySumSeq(float *res, const DenseMatrix *arg, DaphneContext *ctx) { + std::cerr << "hello from mySumSeq()" << std::endl; + const float *valuesArg = arg->getValues(); + *res = 0; + for (size_t r = 0; r < arg->getNumRows(); r++) { + for (size_t c = 0; c < arg->getNumCols(); c++) + *res += valuesArg[c]; + valuesArg += arg->getRowSkip(); } - - // Custom SIMD-enabled sum-kernel. - void mySumSIMD( - float * res, - const DenseMatrix * arg, - DaphneContext * ctx - ) { - std::cerr << "hello from mySumSIMD()" << std::endl; +} - // Validation. - const size_t numCells = arg->getNumRows() * arg->getNumCols(); - if(numCells % 8) - throw std::runtime_error( - "for simplicity, the number of cells must be " - "a multiple of 8" - ); - if(arg->getNumCols() != arg->getRowSkip()) - throw std::runtime_error( - "for simplicity, the argument must not be " - "a column segment of another matrix" - ); - - // SIMD accumulation (8x f32). - const float * valuesArg = arg->getValues(); - __m256 acc = _mm256_setzero_ps(); - for(size_t i = 0; i < numCells / 8; i++) { - acc = _mm256_add_ps(acc, _mm256_loadu_ps(valuesArg)); - valuesArg += 8; - } - - // Summation of accumulator elements. - *res = - (reinterpret_cast(&acc))[0] + - (reinterpret_cast(&acc))[1] + - (reinterpret_cast(&acc))[2] + - (reinterpret_cast(&acc))[3] + - (reinterpret_cast(&acc))[4] + - (reinterpret_cast(&acc))[5] + - (reinterpret_cast(&acc))[6] + - (reinterpret_cast(&acc))[7]; +// Custom SIMD-enabled sum-kernel. +void mySumSIMD(float *res, const DenseMatrix *arg, DaphneContext *ctx) { + std::cerr << "hello from mySumSIMD()" << std::endl; + + // Validation. + const size_t numCells = arg->getNumRows() * arg->getNumCols(); + if (numCells % 8) + throw std::runtime_error("for simplicity, the number of cells must be " + "a multiple of 8"); + if (arg->getNumCols() != arg->getRowSkip()) + throw std::runtime_error("for simplicity, the argument must not be " + "a column segment of another matrix"); + + // SIMD accumulation (8x f32). + const float *valuesArg = arg->getValues(); + __m256 acc = _mm256_setzero_ps(); + for (size_t i = 0; i < numCells / 8; i++) { + acc = _mm256_add_ps(acc, _mm256_loadu_ps(valuesArg)); + valuesArg += 8; } + + // Summation of accumulator elements. + *res = (reinterpret_cast(&acc))[0] + (reinterpret_cast(&acc))[1] + + (reinterpret_cast(&acc))[2] + (reinterpret_cast(&acc))[3] + + (reinterpret_cast(&acc))[4] + (reinterpret_cast(&acc))[5] + + (reinterpret_cast(&acc))[6] + (reinterpret_cast(&acc))[7]; +} } \ No newline at end of file diff --git a/src/api/cli/DaphneUserConfig.h b/src/api/cli/DaphneUserConfig.h index bccbe0b92..75f7c3255 100644 --- a/src/api/cli/DaphneUserConfig.h +++ b/src/api/cli/DaphneUserConfig.h @@ -43,6 +43,7 @@ struct DaphneUserConfig { bool use_ipa_const_propa = true; bool use_phy_op_selection = true; bool use_mlir_codegen = false; + bool save_csv_as_bin = false; int matmul_vec_size_bits = 0; bool matmul_tile = false; int matmul_unroll_factor = 1; diff --git a/src/api/internal/daphne_internal.cpp b/src/api/internal/daphne_internal.cpp index 4a8cac63a..92f26d0b3 100644 --- a/src/api/internal/daphne_internal.cpp +++ b/src/api/internal/daphne_internal.cpp @@ -202,6 +202,8 @@ int startDAPHNE(int argc, const char **argv, DaphneLibResult *daphneLibRes, int "execution engine " "(default is equal to the number of physical cores on the target " "node that executes the code)")); + static opt dbdfReadOptimization("use-dbdf-optimization", cat(daphneOptions), + desc("Enable optimization of multiple csv reads by saving file as dbdf.")); static opt minimumTaskSize("grain-size", cat(schedulingOptions), desc("Define the minimum grain size of a task (default is 1)"), init(1)); static opt useVectorizedPipelines("vec", cat(schedulingOptions), desc("Enable vectorized execution engine")); @@ -427,7 +429,7 @@ int startDAPHNE(int argc, const char **argv, DaphneLibResult *daphneLibRes, int spdlog::warn("No backend has been selected. Wiil use the default 'MPI'"); } user_config.max_distributed_serialization_chunk_size = maxDistrChunkSize; - + user_config.save_csv_as_bin = dbdfReadOptimization; // only overwrite with non-defaults if (use_hdfs) { user_config.use_hdfs = use_hdfs; diff --git a/src/parser/config/ConfigParser.cpp b/src/parser/config/ConfigParser.cpp index 47d3def14..1534393d9 100644 --- a/src/parser/config/ConfigParser.cpp +++ b/src/parser/config/ConfigParser.cpp @@ -57,6 +57,8 @@ void ConfigParser::readUserConfig(const std::string &filename, DaphneUserConfig config.use_phy_op_selection = jf.at(DaphneConfigJsonParams::USE_PHY_OP_SELECTION).get(); if (keyExists(jf, DaphneConfigJsonParams::USE_MLIR_CODEGEN)) config.use_mlir_codegen = jf.at(DaphneConfigJsonParams::USE_MLIR_CODEGEN).get(); + if (keyExists(jf, DaphneConfigJsonParams::SAVE_CSV_AS_BIN)) + config.save_csv_as_bin = jf.at(DaphneConfigJsonParams::SAVE_CSV_AS_BIN).get(); if (keyExists(jf, DaphneConfigJsonParams::MATMUL_VEC_SIZE_BITS)) config.matmul_vec_size_bits = jf.at(DaphneConfigJsonParams::MATMUL_VEC_SIZE_BITS).get(); if (keyExists(jf, DaphneConfigJsonParams::MATMUL_TILE)) diff --git a/src/parser/config/JsonParams.h b/src/parser/config/JsonParams.h index 3a6717497..fc4b17a73 100644 --- a/src/parser/config/JsonParams.h +++ b/src/parser/config/JsonParams.h @@ -30,6 +30,7 @@ struct DaphneConfigJsonParams { inline static const std::string USE_IPA_CONST_PROPA = "use_ipa_const_propa"; inline static const std::string USE_PHY_OP_SELECTION = "use_phy_op_selection"; inline static const std::string USE_MLIR_CODEGEN = "use_mlir_codegen"; + inline static const std::string SAVE_CSV_AS_BIN = "save_csv_as_bin"; inline static const std::string MATMUL_VEC_SIZE_BITS = "matmul_vec_size_bits"; inline static const std::string MATMUL_TILE = "matmul_tile"; inline static const std::string MATMUL_FIXED_TILE_SIZES = "matmul_fixed_tile_sizes"; @@ -61,6 +62,7 @@ struct DaphneConfigJsonParams { inline static const std::string TASK_PARTITIONING_SCHEME = "taskPartitioningScheme"; inline static const std::string NUMBER_OF_THREADS = "numberOfThreads"; inline static const std::string MINIMUM_TASK_SIZE = "minimumTaskSize"; + inline static const std::string NUMBER_OF_SAMPLE_ROWS = "numberOfSampleRows"; inline static const std::string USE_HDFS_ = "useHdfs"; inline static const std::string HDFS_ADDRESS = "hdfsAddress"; inline static const std::string HDFS_USERNAME = "hdfsUsername"; @@ -114,5 +116,6 @@ struct DaphneConfigJsonParams { DAPHNEDSL_IMPORT_PATHS, LOGGING, FORCE_CUDA, - SPARSITY_THRESHOLD}; + SPARSITY_THRESHOLD, + SAVE_CSV_AS_BIN}; }; diff --git a/src/parser/metadata/CMakeLists.txt b/src/parser/metadata/CMakeLists.txt index cbbbb7337..34f72f43a 100644 --- a/src/parser/metadata/CMakeLists.txt +++ b/src/parser/metadata/CMakeLists.txt @@ -15,3 +15,4 @@ add_library(DaphneMetaDataParser STATIC MetaDataParser.cpp ) +target_link_libraries(DaphneMetaDataParser PRIVATE IO) \ No newline at end of file diff --git a/src/runtime/local/io/File.h b/src/runtime/local/io/File.h index 7b2272ebc..a7d2992a0 100644 --- a/src/runtime/local/io/File.h +++ b/src/runtime/local/io/File.h @@ -17,6 +17,7 @@ #ifndef SRC_RUNTIME_LOCAL_IO_FILE_H #define SRC_RUNTIME_LOCAL_IO_FILE_H +#include #include #include diff --git a/src/runtime/local/io/ReadCsv.h b/src/runtime/local/io/ReadCsv.h index 81e6938e4..9978f3953 100644 --- a/src/runtime/local/io/ReadCsv.h +++ b/src/runtime/local/io/ReadCsv.h @@ -41,26 +41,29 @@ // **************************************************************************** template struct ReadCsv { - static void apply(DTRes *&res, const char *filename, size_t numRows, size_t numCols, char delim) = delete; + static void apply(DTRes *&res, const char *filename, size_t numRows, size_t numCols, char delim, + bool saveBin = false) = delete; static void apply(DTRes *&res, const char *filename, size_t numRows, size_t numCols, ssize_t numNonZeros, bool sorted = true) = delete; static void apply(DTRes *&res, const char *filename, size_t numRows, size_t numCols, char delim, - ValueTypeCode *schema) = delete; + ValueTypeCode *schema, bool saveBin = false) = delete; }; // **************************************************************************** // Convenience function // **************************************************************************** -template void readCsv(DTRes *&res, const char *filename, size_t numRows, size_t numCols, char delim) { - ReadCsv::apply(res, filename, numRows, numCols, delim); +template +void readCsv(DTRes *&res, const char *filename, size_t numRows, size_t numCols, char delim, bool saveBin = false) { + ReadCsv::apply(res, filename, numRows, numCols, delim, saveBin); } template -void readCsv(DTRes *&res, const char *filename, size_t numRows, size_t numCols, char delim, ValueTypeCode *schema) { - ReadCsv::apply(res, filename, numRows, numCols, delim, schema); +void readCsv(DTRes *&res, const char *filename, size_t numRows, size_t numCols, char delim, ValueTypeCode *schema, + bool saveBin = false) { + ReadCsv::apply(res, filename, numRows, numCols, delim, schema, saveBin); } template @@ -78,9 +81,10 @@ void readCsv(DTRes *&res, const char *filename, size_t numRows, size_t numCols, // ---------------------------------------------------------------------------- template struct ReadCsv> { - static void apply(DenseMatrix *&res, const char *filename, size_t numRows, size_t numCols, char delim) { + static void apply(DenseMatrix *&res, const char *filename, size_t numRows, size_t numCols, char delim, + bool saveBin = false) { struct File *file = openFile(filename); - readCsvFile(res, file, numRows, numCols, delim); + readCsvFile(res, file, numRows, numCols, delim, filename, saveBin); closeFile(file); } }; @@ -104,9 +108,9 @@ template struct ReadCsv> { template <> struct ReadCsv { static void apply(Frame *&res, const char *filename, size_t numRows, size_t numCols, char delim, - ValueTypeCode *schema) { + ValueTypeCode *schema, bool saveBin = false) { struct File *file = openFile(filename); - readCsvFile(res, file, numRows, numCols, delim, schema); + readCsvFile(res, file, numRows, numCols, delim, schema, filename, saveBin); closeFile(file); } }; diff --git a/src/runtime/local/io/ReadCsvFile.h b/src/runtime/local/io/ReadCsvFile.h index 4cb208f45..2b9dabdd9 100644 --- a/src/runtime/local/io/ReadCsvFile.h +++ b/src/runtime/local/io/ReadCsvFile.h @@ -20,7 +20,8 @@ #include #include #include - +#include +#include #include #include @@ -29,6 +30,7 @@ #include #include +#include #include #include #include @@ -40,26 +42,30 @@ // **************************************************************************** template struct ReadCsvFile { - static void apply(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim) = delete; + static void apply(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim, + const char *filename = nullptr, bool saveBin = false) = delete; static void apply(DTRes *&res, File *file, size_t numRows, size_t numCols, ssize_t numNonZeros, bool sorted = true) = delete; - static void apply(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim, - ValueTypeCode *schema) = delete; + static void apply(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim, ValueTypeCode *schema, + const char *filename = nullptr, bool saveBin = false) = delete; }; // **************************************************************************** // Convenience function // **************************************************************************** -template void readCsvFile(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim) { - ReadCsvFile::apply(res, file, numRows, numCols, delim); +template +void readCsvFile(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim, const char *filename = nullptr, + bool saveBin = false) { + ReadCsvFile::apply(res, file, numRows, numCols, delim, filename, saveBin); } template -void readCsvFile(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim, ValueTypeCode *schema) { - ReadCsvFile::apply(res, file, numRows, numCols, delim, schema); +void readCsvFile(DTRes *&res, File *file, size_t numRows, size_t numCols, char delim, ValueTypeCode *schema, + const char *filename = nullptr, bool saveBin = false) { + ReadCsvFile::apply(res, file, numRows, numCols, delim, schema, filename, saveBin); } template @@ -77,7 +83,8 @@ void readCsvFile(DTRes *&res, File *file, size_t numRows, size_t numCols, char d // ---------------------------------------------------------------------------- template struct ReadCsvFile> { - static void apply(DenseMatrix *&res, struct File *file, size_t numRows, size_t numCols, char delim) { + static void apply(DenseMatrix *&res, struct File *file, size_t numRows, size_t numCols, char delim, + const char *filename = nullptr, bool saveBin = false) { if (file == nullptr) throw std::runtime_error("ReadCsvFile: requires a file to be " "specified (must not be nullptr)"); @@ -90,6 +97,26 @@ template struct ReadCsvFile> { res = DataObjectFactory::create>(numRows, numCols, false); } + using clock = std::chrono::high_resolution_clock; + auto time = clock::now(); + + if (saveBin && filename != nullptr) { + std::string daphneFile = getDaphneFile(filename); + if (std::filesystem::exists(daphneFile)) { + try { + + readDaphne(res, daphneFile.c_str()); + std::cout << "READ_TYPE=second,READ_TIME=" + << std::chrono::duration_cast>(clock::now() - time).count() + << std::endl; + return; + } catch (std::exception &e) { + // Fallback to default branch. + } + } + } + + // default branch size_t cell = 0; VT *valuesRes = res->getValues(); @@ -120,11 +147,24 @@ template struct ReadCsvFile> { } } } + if (saveBin) { + auto writeTime = clock::now(); + writeDaphne(res, getDaphneFile(filename).c_str()); + std::cout << "OPERATION=write_bin,WRITE_TIME=" + << std::chrono::duration_cast>(clock::now() - writeTime).count() + << std::endl; + std::cout.flush(); + } + std::string message = (saveBin) ? "READ_TYPE=first,READ_TIME=" : "READ_TYPE=normal,READ_TIME="; + std::cout << message << std::chrono::duration_cast>(clock::now() - time).count() + << std::endl; + std::cout.flush(); } }; template <> struct ReadCsvFile> { - static void apply(DenseMatrix *&res, struct File *file, size_t numRows, size_t numCols, char delim) { + static void apply(DenseMatrix *&res, struct File *file, size_t numRows, size_t numCols, char delim, + const char *filename = nullptr, bool saveBin = false) { if (file == nullptr) throw std::runtime_error("ReadCsvFile: requires a file to be specified (must not be nullptr)"); if (numRows <= 0) @@ -155,7 +195,8 @@ template <> struct ReadCsvFile> { }; template <> struct ReadCsvFile> { - static void apply(DenseMatrix *&res, struct File *file, size_t numRows, size_t numCols, char delim) { + static void apply(DenseMatrix *&res, struct File *file, size_t numRows, size_t numCols, char delim, + const char *filename = nullptr, bool saveBin = false) { if (file == nullptr) throw std::runtime_error("ReadCsvFile: requires a file to be specified (must not be nullptr)"); if (numRows <= 0) @@ -291,8 +332,11 @@ template struct ReadCsvFile> { // ---------------------------------------------------------------------------- template <> struct ReadCsvFile { - static void apply(Frame *&res, struct File *file, size_t numRows, size_t numCols, char delim, - ValueTypeCode *schema) { + static void apply(Frame *&res, struct File *file, size_t numRows, size_t numCols, char delim, ValueTypeCode *schema, + const char *filename, bool saveBin = false) { + if (file == nullptr) + throw std::runtime_error("ReadCsvFile: requires a file to be specified (must not be nullptr): " + + std::string(filename)); if (numRows <= 0) throw std::runtime_error("ReadCsvFile: numRows must be > 0"); if (numCols <= 0) @@ -301,27 +345,42 @@ template <> struct ReadCsvFile { if (res == nullptr) { res = DataObjectFactory::create(numRows, numCols, schema, nullptr, false); } + using clock = std::chrono::high_resolution_clock; + auto time = clock::now(); + if (saveBin && filename != nullptr) { + if (std::filesystem::exists(getDaphneFile(filename))) { + try { + std::string daphneFile = getDaphneFile(filename); + readDaphne(res, daphneFile.c_str()); + std::cout << "READ_TYPE=second,READ_TIME=" + << std::chrono::duration_cast>(clock::now() - time).count() + << std::endl; + std::cout.flush(); + return; + } catch (std::exception &e) { + // Fallback to default branch. + } + } + } - size_t row = 0, col = 0; - - uint8_t **rawCols = new uint8_t *[numCols]; - ValueTypeCode *colTypes = new ValueTypeCode[numCols]; + auto **rawCols = new uint8_t *[numCols]; + auto *colTypes = new ValueTypeCode[numCols]; for (size_t i = 0; i < numCols; i++) { rawCols[i] = reinterpret_cast(res->getColumnRaw(i)); colTypes[i] = res->getColumnType(i); } - while (1) { + // using clock = std::chrono::high_resolution_clock; + // auto time = clock::now(); + for (size_t row = 0; row < numRows; row++) { ssize_t ret = getFileLine(file); - if (file->read == EOF) - break; - if (file->line == NULL) + if ((file->read == EOF) || (file->line == NULL)) break; if (ret == -1) throw std::runtime_error("ReadCsvFile::apply: getFileLine failed"); size_t pos = 0; - while (1) { + for (size_t col = 0; col < numCols; col++) { switch (colTypes[col]) { case ValueTypeCode::SI8: int8_t val_si8; @@ -378,27 +437,31 @@ template <> struct ReadCsvFile { default: throw std::runtime_error("ReadCsvFile::apply: unknown value type code"); } - - if (++col >= numCols) { - break; + if (col < numCols - 1) { + // Advance pos until next delimiter + while (file->line[pos] != delim) + pos++; + pos++; // skip delimiter } - - // TODO We could even exploit the fact that the strtoX functions - // can return a pointer to the first character after the parsed - // input, then we wouldn't have to search for that ourselves, - // just would need to check if it is really the delimiter. - while (file->line[pos] != delim) - pos++; - pos++; // skip delimiter } + } - if (++row >= numRows) { - break; + if (saveBin && !std::filesystem::exists(getDaphneFile(filename))) { + if (!hasString(res->getNumCols(), res->getSchema())) { // daphne's binary format does not support strings + // yet + auto writeTime = clock::now(); + writeDaphne(res, getDaphneFile(filename).c_str()); + std::cout << "OPERATION=write_bin,WRITE_TIME=" + << std::chrono::duration_cast>(clock::now() - writeTime).count() + << std::endl; + std::cout.flush(); } - col = 0; } - + std::string message = (saveBin) ? "READ_TYPE=first,READ_TIME=" : "READ_TYPE=normal,READ_TIME="; + std::cout << message << std::chrono::duration_cast>(clock::now() - time).count() + << std::endl; + std::cout.flush(); delete[] rawCols; delete[] colTypes; } -}; +}; \ No newline at end of file diff --git a/src/runtime/local/io/utils.cpp b/src/runtime/local/io/utils.cpp index 64be1c53d..6e7050f22 100644 --- a/src/runtime/local/io/utils.cpp +++ b/src/runtime/local/io/utils.cpp @@ -14,4 +14,4 @@ * limitations under the License. */ -#include \ No newline at end of file +#include diff --git a/src/runtime/local/io/utils.h b/src/runtime/local/io/utils.h index 97ef3b002..85dbe2b23 100644 --- a/src/runtime/local/io/utils.h +++ b/src/runtime/local/io/utils.h @@ -23,6 +23,17 @@ #include #include +#include + +// Function to check if schema is valid for daphne's binary format +inline bool hasString(size_t numCols, const ValueTypeCode *schema) { + for (size_t i = 0; i < numCols; i++) { + if (schema[i] >= ValueTypeCode::STR) + return true; + } + return false; +} + // Conversion of std::string. inline void convertStr(std::string const &x, double *v) { @@ -72,6 +83,7 @@ inline void convertCstr(const char *x, int64_t *v) { *v = atoi(x); } inline void convertCstr(const char *x, uint8_t *v) { *v = atoi(x); } inline void convertCstr(const char *x, uint32_t *v) { *v = atoi(x); } inline void convertCstr(const char *x, uint64_t *v) { *v = atoi(x); } +inline static std::string getDaphneFile(const char *filename) { return std::string(filename) + ".dbdf"; } /** * @brief This function reads a CSV column that contains strings. @@ -133,3 +145,38 @@ inline size_t setCString(struct File *file, size_t start_pos, std::string *res, else return pos + start_pos; } + +inline size_t setCString(const char *linePtr, size_t start_pos, std::string *res, const char delim) { + size_t pos = start_pos; + bool inQuotes = false; + // If the field starts with a quote, we are in a quoted field. + if (linePtr[pos] == '"') { + inQuotes = true; + pos++; // skip opening quote + } + while (linePtr[pos] != '\0') { + if (inQuotes && linePtr[pos] == '"') { + // Check if this is a doubled quote. + if (linePtr[pos + 1] == '"') { + res->append("\"\""); // append two quotes + pos += 2; + continue; + } else { // closing quote. + pos++; + break; + } + } + // In unquoted fields, stop at the delimiter or newline. + if (!inQuotes && (linePtr[pos] == delim || linePtr[pos] == '\n' || linePtr[pos] == '\r')) + break; + // Handle backslash-escaped quote inside a quoted field. + if (inQuotes && linePtr[pos] == '\\' && linePtr[pos + 1] == '"') { + res->append("\\\""); // append backslash and quote + pos += 2; + continue; + } + res->push_back(linePtr[pos]); + pos++; + } + return pos; +} \ No newline at end of file diff --git a/src/runtime/local/kernels/Read.h b/src/runtime/local/kernels/Read.h index 9993602eb..deaa23784 100644 --- a/src/runtime/local/kernels/Read.h +++ b/src/runtime/local/kernels/Read.h @@ -79,14 +79,14 @@ template void read(DTRes *&res, const char *filename, DCTX(ctx)) { template struct Read> { static void apply(DenseMatrix *&res, const char *filename, DCTX(ctx)) { - FileMetaData fmd = MetaDataParser::readMetaData(filename); + bool save_csv_as_bin = ctx != nullptr && ctx->getUserConfig().save_csv_as_bin; int extv = extValue(filename); switch (extv) { case 0: if (res == nullptr) res = DataObjectFactory::create>(fmd.numRows, fmd.numCols, false); - readCsv(res, filename, fmd.numRows, fmd.numCols, ','); + readCsv(res, filename, fmd.numRows, fmd.numCols, ',', save_csv_as_bin); break; case 1: if constexpr (std::is_same::value) @@ -170,8 +170,8 @@ template struct Read> { template <> struct Read { static void apply(Frame *&res, const char *filename, DCTX(ctx)) { + bool save_csv_as_bin = ctx != nullptr && ctx->getUserConfig().save_csv_as_bin; FileMetaData fmd = MetaDataParser::readMetaData(filename); - ValueTypeCode *schema; if (fmd.isSingleValueType) { schema = new ValueTypeCode[fmd.numCols]; @@ -189,7 +189,7 @@ template <> struct Read { if (res == nullptr) res = DataObjectFactory::create(fmd.numRows, fmd.numCols, schema, labels, false); - readCsv(res, filename, fmd.numRows, fmd.numCols, ',', schema); + readCsv(res, filename, fmd.numRows, fmd.numCols, ',', schema, save_csv_as_bin); if (fmd.isSingleValueType) delete[] schema; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index ea548b82c..0e9a9cd73 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -36,6 +36,7 @@ set(TEST_SOURCES api/cli/indexing/IndexingTest.cpp api/cli/inference/InferenceTest.cpp api/cli/io/ReadWriteTest.cpp + api/cli/io/ReadOptimizationEvaluation.cpp api/cli/lists/ListsTest.cpp api/cli/literals/LiteralsTest.cpp api/cli/operations/ConstantFoldingTest.cpp diff --git a/test/api/cli/io/ReadOptimizationEvaluation.cpp b/test/api/cli/io/ReadOptimizationEvaluation.cpp new file mode 100644 index 000000000..2811b77fc --- /dev/null +++ b/test/api/cli/io/ReadOptimizationEvaluation.cpp @@ -0,0 +1,261 @@ +/* + * Copyright 2021 The DAPHNE Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include + +#include +#include +#include + +std::string createDaphneScript(const std::string &evaluationDir, const std::string &csvFilename, + const std::string &daphneScript) { + std::filesystem::create_directories(evaluationDir); // ensure directory exists + std::string daphneFilePath = evaluationDir + daphneScript; + if (std::filesystem::exists(daphneFilePath)) { + return daphneFilePath; + } + std::ofstream ofs(daphneFilePath); + if (!ofs) { + throw std::runtime_error("Could not create Daphne script file: " + daphneFilePath); + } + ofs << "readFrame(\"" << evaluationDir + csvFilename << "\");"; + ofs.close(); + return daphneFilePath; +} + +template std::string runDaphneEval(const std::string &scriptFilePath, Args... args) { + std::stringstream out; + std::stringstream err; + int status = runDaphne(out, err, args..., scriptFilePath.c_str()); + + // Just CHECK (don't REQUIRE) success, such that in case of a failure, the + // checks of out and err still run and provide useful messages. For err, + // don't check empty(), because then catch2 doesn't display the error + // output. + CHECK(status == StatusCode::SUCCESS); + // std::cout << out.str() << std::endl; + // CHECK(err.str() == ""); + return out.str() + err.str(); +} +// New data structure for timing values. +struct TimingData { + // read time in nanoseconds as string (without the "ns" suffix) + std::string readTime; + std::string writeTime; + double startupSeconds = 0.0; + double parsingSeconds = 0.0; + double compilationSeconds = 0.0; + double executionSeconds = 0.0; + double totalSeconds = 0.0; +}; + +// This function extracts timing information from the output string. +// Expected output format: +// read time: 117784ns +// {"startup_seconds": 0.0136333, "parsing_seconds": 0.000770869, "compilation_seconds": 0.0182154, +// "execution_seconds": 0.00726858, "total_seconds": 0.0398881} +TimingData extractTiming(const std::string &output, bool expectWriteTime = false) { + TimingData timingData; + std::istringstream iss(output); + std::string line; + // First line: read time. + if (std::getline(iss, line)) { + auto pos = line.find(":"); + if (pos != std::string::npos) { + std::string val = line.substr(pos + 1); + // Trim leading spaces. + while (!val.empty() && std::isspace(val.front())) { + val.erase(val.begin()); + } + // Remove "ns" suffix if present. + if (val.size() >= 2 && val.substr(val.size() - 2) == "ns") { + val = val.substr(0, val.size() - 2); + } + timingData.readTime = val; + } + } + // Second line has write time + if (expectWriteTime) { + if (std::getline(iss, line)) { + auto pos = line.find(":"); + if (pos != std::string::npos) { + std::string val = line.substr(pos + 1); + // Trim leading spaces. + while (!val.empty() && std::isspace(val.front())) { + val.erase(val.begin()); + } + // Remove "ns" suffix if present. + if (val.size() >= 2 && val.substr(val.size() - 2) == "ns") { + val = val.substr(0, val.size() - 2); + } + timingData.writeTime = val; + } + } + } + + // Second line: JSON with detailed timings. + if (std::getline(iss, line)) { + std::smatch match; + std::regex regex_startup("\"startup_seconds\"\\s*:\\s*([0-9]*\\.?[0-9]+)"); + if (std::regex_search(line, match, regex_startup)) { + timingData.startupSeconds = std::stod(match[1].str()); + } + std::regex regex_parsing("\"parsing_seconds\"\\s*:\\s*([0-9]*\\.?[0-9]+)"); + if (std::regex_search(line, match, regex_parsing)) { + timingData.parsingSeconds = std::stod(match[1].str()); + } + std::regex regex_compilation("\"compilation_seconds\"\\s*:\\s*([0-9]*\\.?[0-9]+)"); + if (std::regex_search(line, match, regex_compilation)) { + timingData.compilationSeconds = std::stod(match[1].str()); + } + std::regex regex_execution("\"execution_seconds\"\\s*:\\s*([0-9]*\\.?[0-9]+)"); + if (std::regex_search(line, match, regex_execution)) { + timingData.executionSeconds = std::stod(match[1].str()); + } + std::regex regex_total("\"total_seconds\"\\s*:\\s*([0-9]*\\.?[0-9]+)"); + if (std::regex_search(line, match, regex_total)) { + timingData.totalSeconds = std::stod(match[1].str()); + } + } + return timingData; +} + +void writeResultsToFile(const std::string &feature, const std::string &csvFilename, bool opt, bool firstRead, + const TimingData &timingData) { + const std::string resultsFile = "evaluation/evaluation_results_" + feature + ".csv"; + bool fileExists = std::filesystem::exists(resultsFile); + std::ofstream ofs(resultsFile, std::ios::app); + if (!ofs) { + throw std::runtime_error("Could not open " + resultsFile + " for writing."); + } + if (!fileExists) { + ofs << "CSVFile,OptEnabled,FirstRead,NumCols,NumRows,FileType,ReadTime,WriteTime,StartupSeconds,ParsingSeconds," + "CompilationSeconds,ExecutionSeconds,TotalSeconds,WriteTime\n"; + } + + // Extract numRows, numCols, and FileType from the filename. + // Expected format: data_r_c_.csv + std::string baseFilename = csvFilename; + size_t pos = baseFilename.rfind(".csv"); + if (pos != std::string::npos) { + baseFilename = baseFilename.substr(0, pos); + } + std::vector parts; + std::istringstream iss(baseFilename); + std::string token; + while (std::getline(iss, token, '_')) { + parts.push_back(token); + } + int numRows = 0, numCols = 0; + std::string type = ""; + if (parts.size() >= 4) { + // parts[0] is "data", parts[1] is "r", parts[2] is "c", parts[3] is "" + std::string rowToken = parts[1]; // e.g. "1000r" + std::string colToken = parts[2]; // e.g. "10c" + if (!rowToken.empty() && rowToken.back() == 'r') { + rowToken.pop_back(); // remove trailing 'r' + } + if (!colToken.empty() && colToken.back() == 'c') { + colToken.pop_back(); // remove trailing 'c' + } + numRows = std::stoi(rowToken); + numCols = std::stoi(colToken); + type = parts[3]; + } + + std::string optStr = opt ? "true" : "false"; + std::string firstReadStr = firstRead ? "true" : "false"; + ofs << csvFilename << "," << optStr << "," << firstReadStr << "," << numCols << "," << numRows << "," << type << "," + << timingData.readTime << "," << timingData.writeTime << "," << timingData.startupSeconds << "," + << timingData.parsingSeconds << "," << timingData.compilationSeconds << "," << timingData.executionSeconds + << "," << timingData.totalSeconds << "\n"; + ofs.close(); +} + +void runEvalTestCase(const std::string &csvFilename, std::string daphneScript = "", + const std::string &dirPath = "evaluation/") { + // Remove potential binary output file. + std::filesystem::remove(dirPath + csvFilename + ".dbdf"); + if (daphneScript.empty()) { + daphneScript = createDaphneScript(dirPath, csvFilename, csvFilename + ".daphne"); + } else { + daphneScript = dirPath + daphneScript; + } + + // Normal read for comparison. + std::string output = runDaphneEval(daphneScript, "--timing"); + std::cout << output << std::endl; + TimingData timingData = extractTiming(output); + writeResultsToFile("binopt", csvFilename, false, true, timingData); + + // Build binary file and positional map on first read. + output = runDaphneEval(daphneScript, "--timing", "--use-dbdf-optimization"); + std::cout << output << std::endl; + timingData = extractTiming(output, true); + writeResultsToFile("binopt", csvFilename, true, true, timingData); + CHECK(std::filesystem::exists(dirPath + csvFilename + ".dbdf")); + + // Subsequent read. + output = runDaphneEval(daphneScript, "--timing", "--use-dbdf-optimization"); + std::cout << output << std::endl; + timingData = extractTiming(output); + writeResultsToFile("binopt", csvFilename, true, false, timingData); +} + +TEST_CASE("EvalTestFrameNumber60KB", TAG_IO) { + // Example instantiation. + const std::string csvFilename = "data_1000r_10c_NUMBER.csv"; + const std::string daphneScript = "evalReadFrame.daphne"; + runEvalTestCase(csvFilename, daphneScript); +} + +TEST_CASE("EvalTestFrameNumber6MB", TAG_IO) { + // Example instantiation. + const std::string csvFilename = "data_1000r_1000c_NUMBER.csv"; + const std::string daphneScript = "evalReadFrame2.daphne"; + runEvalTestCase(csvFilename); //, daphneScript); +} + +const std::string dirPath = "evaluation/"; +TEST_CASE("evalFrameFromCSVBinOpt", TAG_IO) { + // assumes file has been generated via create_csv.py in /daphne + std::string filename = "data_1000r_10c_NUMBER.csv"; + std::filesystem::remove(dirPath + filename + ".dbdf"); + // normal read for comparison + std::string output; + output = runDaphneEval(dirPath + "evalReadFrame.daphne", "--timing"); + std::cout << output << std::endl; + + std::string timing, readTime, writeTime; + TimingData timingData = extractTiming(output); + writeResultsToFile("binopt", filename, false, true, timingData); + + // build binary file and positional map on first read + output = runDaphneEval(dirPath + "evalReadFrame.daphne", "--timing", "--use-dbdf-optimization"); + std::cout << output << std::endl; + timingData = extractTiming(output, true); + writeResultsToFile("binopt", filename, true, true, timingData); + REQUIRE(std::filesystem::exists(dirPath + filename + ".dbdf")); + + output = runDaphneEval(dirPath + "evalReadFrame.daphne", "--timing", "--use-dbdf-optimization"); + std::cout << output << std::endl; + timingData = extractTiming(output); + writeResultsToFile("binopt", filename, true, false, timingData); +} \ No newline at end of file diff --git a/test/api/cli/io/ReadWriteTest.cpp b/test/api/cli/io/ReadWriteTest.cpp index e782ac80d..139106da8 100644 --- a/test/api/cli/io/ReadWriteTest.cpp +++ b/test/api/cli/io/ReadWriteTest.cpp @@ -21,6 +21,8 @@ #include #include +#include +#include #include const std::string dirPath = "test/api/cli/io/"; @@ -69,6 +71,28 @@ MAKE_READ_TEST_CASE_2("frame_dynamic-path-1") // MAKE_READ_TEST_CASE_2("frame_dynamic-path-2") // MAKE_READ_TEST_CASE_2("frame_dynamic-path-3") +TEST_CASE("readFrameFromCSVBinOpt", TAG_IO) { + std::string filename = dirPath + "ref/ReadCsv1-1.csv"; + std::filesystem::remove(filename + ".dbdf"); + compareDaphneToRef(dirPath + "out/testReadFrameWithNoMeta.txt", dirPath + "read/testReadFrameWithNoMeta.daphne", + "--use-dbdf-optimization"); + REQUIRE(std::filesystem::exists(filename + ".dbdf")); + compareDaphneToRef(dirPath + "out/testReadFrameWithNoMeta.txt", dirPath + "read/testReadFrameWithNoMeta.daphne", + "--use-dbdf-optimization"); + std::filesystem::remove(filename + ".dbdf"); +} + +TEST_CASE("readMatrixFromCSVBinOpt", TAG_IO) { + std::string filename = dirPath + "ref/matrix_si64_ref.csv"; + std::filesystem::remove(filename + ".dbdf"); + compareDaphneToRef(dirPath + "out/testReadStringIntoFrameNoMeta.txt", + dirPath + "read/testReadFrameWithMixedTypes.daphne", "--use-dbdf-optimization"); + REQUIRE(std::filesystem::exists(filename + ".dbdf")); + compareDaphneToRef(dirPath + "out/testReadStringIntoFrameNoMeta.txt", + dirPath + "read/testReadFrameWithMixedTypes.daphne", "--use-dbdf-optimization"); + std::filesystem::remove(filename + ".dbdf"); +} + // ******************************************************************************** // Write test cases // ******************************************************************************** diff --git a/test/api/cli/io/out/testReadFrameWithNoMeta.txt b/test/api/cli/io/out/testReadFrameWithNoMeta.txt new file mode 100644 index 000000000..28bf96794 --- /dev/null +++ b/test/api/cli/io/out/testReadFrameWithNoMeta.txt @@ -0,0 +1,3 @@ +Frame(2x4, [col_0:float, col_1:float, col_2:float, col_3:float]) +-0.1 -0.2 0.1 0.2 +3.14 5.41 6.22216 5 diff --git a/test/api/cli/io/out/testReadStringIntoFrameNoMeta.txt b/test/api/cli/io/out/testReadStringIntoFrameNoMeta.txt new file mode 100644 index 000000000..10287ab93 --- /dev/null +++ b/test/api/cli/io/out/testReadStringIntoFrameNoMeta.txt @@ -0,0 +1,3 @@ +DenseMatrix(2x4, int64_t) +1 -22 3 -44 +5 -66 0 0 diff --git a/test/api/cli/io/read/testReadFrameWithMixedTypes.daphne b/test/api/cli/io/read/testReadFrameWithMixedTypes.daphne new file mode 100644 index 000000000..f98e25f1a --- /dev/null +++ b/test/api/cli/io/read/testReadFrameWithMixedTypes.daphne @@ -0,0 +1,6 @@ +# Test reading from a file when the file path is not trivially constant (i.e., a parameter to a UDF) +def readFrameFromCSV(path: str){ + print(readFrame(path)); +} + +print(readMatrix("test/api/cli/io/ref/matrix_si64_ref.csv")); \ No newline at end of file diff --git a/test/api/cli/io/read/testReadFrameWithNoMeta.daphne b/test/api/cli/io/read/testReadFrameWithNoMeta.daphne new file mode 100644 index 000000000..0724ddbde --- /dev/null +++ b/test/api/cli/io/read/testReadFrameWithNoMeta.daphne @@ -0,0 +1,6 @@ +# Test reading from a file when the file path is not trivially constant (i.e., a parameter to a UDF) +def readFrameFromCSV(path: str){ + print(readFrame(path)); +} + +print(readFrame("test/api/cli/io/ref/ReadCsv1-1.csv")); \ No newline at end of file diff --git a/test/api/cli/io/ref/ReadCsv1-1.csv b/test/api/cli/io/ref/ReadCsv1-1.csv new file mode 100644 index 000000000..79d814f7b --- /dev/null +++ b/test/api/cli/io/ref/ReadCsv1-1.csv @@ -0,0 +1,2 @@ +-0.1,-0.2,0.1,0.2 +3.14,5.41,6.22216,5 diff --git a/test/api/cli/io/ref/ReadCsv1-1.csv.meta b/test/api/cli/io/ref/ReadCsv1-1.csv.meta new file mode 100644 index 000000000..a12f4f17f --- /dev/null +++ b/test/api/cli/io/ref/ReadCsv1-1.csv.meta @@ -0,0 +1,6 @@ +{ + "numRows": 2, + "numCols": 4, + "valueType": "f32", + "numNonZeros": 0 +} \ No newline at end of file diff --git a/test/api/cli/io/ref/ReadCsv3-1.csv b/test/api/cli/io/ref/ReadCsv3-1.csv new file mode 100644 index 000000000..81fa66d93 --- /dev/null +++ b/test/api/cli/io/ref/ReadCsv3-1.csv @@ -0,0 +1,4 @@ +1,-1,"" +2,-2, +3,-3,"multi-line," +4,-4,simple string diff --git a/test/api/cli/io/ref/ReadCsv3-1.csv.meta b/test/api/cli/io/ref/ReadCsv3-1.csv.meta new file mode 100644 index 000000000..fc14ce73d --- /dev/null +++ b/test/api/cli/io/ref/ReadCsv3-1.csv.meta @@ -0,0 +1,18 @@ +{ + "numRows": 4, + "numCols": 3, + "schema": [ + { + "label": "a", + "valueType": "si8" + }, + { + "label": "b", + "valueType": "ui8" + }, + { + "label": "c", + "valueType": "str" + } + ] +} diff --git a/test/api/cli/operations/CanonicalizationConstantFoldingOpTest.cpp b/test/api/cli/operations/CanonicalizationConstantFoldingOpTest.cpp index 37c0f3595..b84acf86c 100644 --- a/test/api/cli/operations/CanonicalizationConstantFoldingOpTest.cpp +++ b/test/api/cli/operations/CanonicalizationConstantFoldingOpTest.cpp @@ -1,45 +1,45 @@ -/* - * Copyright 2023 The DAPHNE Consortium - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include - -const std::string dirPath = "test/api/cli/operations/"; - -void compareDaphneParsingSimplifiedToRef(const std::string &refFilePath, const std::string &scriptFilePath) { - std::stringstream out; - std::stringstream err; - const std::string exp = readTextFile(refFilePath); - int status = runDaphne(out, err, "--explain=parsing_simplified", scriptFilePath.c_str()); - CHECK(status == StatusCode::SUCCESS); - CHECK(err.str() == exp); -} - -TEST_CASE("additive_inverse_constant_folding", TAG_CODEGEN TAG_OPERATIONS) { - const std::string testName = "addinv_constant_folding"; - compareDaphneParsingSimplifiedToRef(dirPath + testName + ".txt", dirPath + testName + ".daphne"); -} - -TEST_CASE("additive_inverse_canonicalization", TAG_CODEGEN TAG_OPERATIONS) { - const std::string testName = "addinv_canonicalization"; - compareDaphneParsingSimplifiedToRef(dirPath + testName + ".txt", dirPath + testName + ".daphne"); -} - -TEST_CASE("binary_operator_casts_constant_folding", TAG_CODEGEN TAG_OPERATIONS) { - const std::string testName = "binary_op_casts_constant_folding"; - compareDaphneParsingSimplifiedToRef(dirPath + testName + ".txt", dirPath + testName + ".daphne"); -} +/* + * Copyright 2023 The DAPHNE Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +const std::string dirPath = "test/api/cli/operations/"; + +void compareDaphneParsingSimplifiedToRef(const std::string &refFilePath, const std::string &scriptFilePath) { + std::stringstream out; + std::stringstream err; + const std::string exp = readTextFile(refFilePath); + int status = runDaphne(out, err, "--explain=parsing_simplified", scriptFilePath.c_str()); + CHECK(status == StatusCode::SUCCESS); + CHECK(err.str() == exp); +} + +TEST_CASE("additive_inverse_constant_folding", TAG_CODEGEN TAG_OPERATIONS) { + const std::string testName = "addinv_constant_folding"; + compareDaphneParsingSimplifiedToRef(dirPath + testName + ".txt", dirPath + testName + ".daphne"); +} + +TEST_CASE("additive_inverse_canonicalization", TAG_CODEGEN TAG_OPERATIONS) { + const std::string testName = "addinv_canonicalization"; + compareDaphneParsingSimplifiedToRef(dirPath + testName + ".txt", dirPath + testName + ".daphne"); +} + +TEST_CASE("binary_operator_casts_constant_folding", TAG_CODEGEN TAG_OPERATIONS) { + const std::string testName = "binary_op_casts_constant_folding"; + compareDaphneParsingSimplifiedToRef(dirPath + testName + ".txt", dirPath + testName + ".daphne"); +} diff --git a/test/api/cli/operations/addinv_canonicalization.daphne b/test/api/cli/operations/addinv_canonicalization.daphne index 74f08f598..c82d2b562 100644 --- a/test/api/cli/operations/addinv_canonicalization.daphne +++ b/test/api/cli/operations/addinv_canonicalization.daphne @@ -1,5 +1,5 @@ -print(--2); -print(---3); -print(----4); -print(--log(2,2)); +print(--2); +print(---3); +print(----4); +print(--log(2,2)); print(---log(3,3)); \ No newline at end of file diff --git a/test/api/cli/operations/addinv_constant_folding.daphne b/test/api/cli/operations/addinv_constant_folding.daphne index 62f05d849..7f84460ff 100644 --- a/test/api/cli/operations/addinv_constant_folding.daphne +++ b/test/api/cli/operations/addinv_constant_folding.daphne @@ -1,9 +1,9 @@ -print(-2); -print(+2); -print(--2); -print(++2); -print(+-2); -print(+-+2); -print(-(3*2)); -print(-(3+2)); +print(-2); +print(+2); +print(--2); +print(++2); +print(+-2); +print(+-+2); +print(-(3*2)); +print(-(3+2)); print(-(-2-3)); \ No newline at end of file diff --git a/test/api/cli/operations/binary_op_casts_constant_folding.daphne b/test/api/cli/operations/binary_op_casts_constant_folding.daphne index 9280b9511..b30e318a0 100644 --- a/test/api/cli/operations/binary_op_casts_constant_folding.daphne +++ b/test/api/cli/operations/binary_op_casts_constant_folding.daphne @@ -1,16 +1,16 @@ -print(1 + as.si8(1)); -print(2 + as.si32(1)); -print(3 + as.si64(1)); -print(4 + as.ui8(1)); -print(5 + as.ui32(1)); -print(6 + as.ui64(1)); - -print(10.0 + as.f32(1)); -print(11.0 + as.f64(1)); - -print(as.si32(7) + as.si8(1)); -print(as.si64(8) + as.si32(1)); -print(as.si8(9) + as.si64(1)); - -print(as.f64(12.0) + as.f32(1)); +print(1 + as.si8(1)); +print(2 + as.si32(1)); +print(3 + as.si64(1)); +print(4 + as.ui8(1)); +print(5 + as.ui32(1)); +print(6 + as.ui64(1)); + +print(10.0 + as.f32(1)); +print(11.0 + as.f64(1)); + +print(as.si32(7) + as.si8(1)); +print(as.si64(8) + as.si32(1)); +print(as.si8(9) + as.si64(1)); + +print(as.f64(12.0) + as.f32(1)); print(as.f32(13.0) + as.f64(1)); \ No newline at end of file diff --git a/test/api/cli/parser/ReadCsv1.csv b/test/api/cli/parser/ReadCsv1.csv new file mode 100644 index 000000000..79d814f7b --- /dev/null +++ b/test/api/cli/parser/ReadCsv1.csv @@ -0,0 +1,2 @@ +-0.1,-0.2,0.1,0.2 +3.14,5.41,6.22216,5 diff --git a/test/api/python/data_transfer_numpy_3.daphne b/test/api/python/data_transfer_numpy_3.daphne index 8302b7d00..03ef30140 100644 --- a/test/api/python/data_transfer_numpy_3.daphne +++ b/test/api/python/data_transfer_numpy_3.daphne @@ -1,27 +1,27 @@ -/* - * Copyright 2022 The DAPHNE Consortium - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -m1 = reshape(seq(0, 7), 2, 4); -m2 = reshape(seq(0, 26), 3, 9); -m3 = reshape(seq(0, 31), 2, 16); -print(m1); -print(m2); -print(m3); - -# verify that the original_shapes of DaphneLib, match the returned output -print("(2, 2, 2)"); -print("(3, 3, 3)"); +/* + * Copyright 2022 The DAPHNE Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +m1 = reshape(seq(0, 7), 2, 4); +m2 = reshape(seq(0, 26), 3, 9); +m3 = reshape(seq(0, 31), 2, 16); +print(m1); +print(m2); +print(m3); + +# verify that the original_shapes of DaphneLib, match the returned output +print("(2, 2, 2)"); +print("(3, 3, 3)"); print("(2, 2, 2, 2, 2)"); \ No newline at end of file diff --git a/test/api/python/data_transfer_numpy_3.py b/test/api/python/data_transfer_numpy_3.py index 6f770f903..4275f4f7e 100644 --- a/test/api/python/data_transfer_numpy_3.py +++ b/test/api/python/data_transfer_numpy_3.py @@ -1,37 +1,37 @@ -#!/usr/bin/python - -# Copyright 2022 The DAPHNE Consortium -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# Data transfer from numpy to DAPHNE and back, via shared memory. - -import numpy as np -from daphne.context.daphne_context import DaphneContext - -m1 = np.arange(8).reshape((2,2,2)) -m2 = np.arange(27).reshape((3,3,3)) -m3 = np.arange(32).reshape((2,2,2,2,2)) - -dctx = DaphneContext() - -X, m1_og_shape = dctx.from_numpy(m1, shared_memory=True, return_shape=True) -Y, m2_og_shape = dctx.from_numpy(m2, shared_memory=True, return_shape=True) -Z, m3_og_shape = dctx.from_numpy(m3, shared_memory=True, return_shape=True) - -X.print().compute() -Y.print().compute() -Z.print().compute() -print(m1_og_shape) -print(m2_og_shape) -print(m3_og_shape) +#!/usr/bin/python + +# Copyright 2022 The DAPHNE Consortium +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Data transfer from numpy to DAPHNE and back, via shared memory. + +import numpy as np +from daphne.context.daphne_context import DaphneContext + +m1 = np.arange(8).reshape((2,2,2)) +m2 = np.arange(27).reshape((3,3,3)) +m3 = np.arange(32).reshape((2,2,2,2,2)) + +dctx = DaphneContext() + +X, m1_og_shape = dctx.from_numpy(m1, shared_memory=True, return_shape=True) +Y, m2_og_shape = dctx.from_numpy(m2, shared_memory=True, return_shape=True) +Z, m3_og_shape = dctx.from_numpy(m3, shared_memory=True, return_shape=True) + +X.print().compute() +Y.print().compute() +Z.print().compute() +print(m1_og_shape) +print(m2_og_shape) +print(m3_og_shape) diff --git a/test/runtime/local/io/ReadCsv1.csv.meta b/test/runtime/local/io/ReadCsv1.csv.meta index 82073032e..a12f4f17f 100644 --- a/test/runtime/local/io/ReadCsv1.csv.meta +++ b/test/runtime/local/io/ReadCsv1.csv.meta @@ -1,6 +1,6 @@ { "numRows": 2, "numCols": 4, - "valueType": "f64", + "valueType": "f32", "numNonZeros": 0 } \ No newline at end of file diff --git a/test/runtime/local/io/ReadCsv6.csv b/test/runtime/local/io/ReadCsv6.csv new file mode 100644 index 000000000..d1c1ac1a8 --- /dev/null +++ b/test/runtime/local/io/ReadCsv6.csv @@ -0,0 +1,6 @@ +222,11.5,world,444,55.6 +444,19.3,"sample,",666,77.8 +555,29.9,"line1line2",777,88.9 +777,15.2,"",999,10.1 +111,31.8,"""\"abc""def\"",333,16.9 +222,13.9,,444,18.2 diff --git a/test/runtime/local/io/ReadCsvCSR.csv b/test/runtime/local/io/ReadCsvCSR.csv new file mode 100644 index 000000000..ade2352bb --- /dev/null +++ b/test/runtime/local/io/ReadCsvCSR.csv @@ -0,0 +1,3 @@ +0,1 +0,2 +1,3 \ No newline at end of file diff --git a/test/runtime/local/io/ReadCsvTest.cpp b/test/runtime/local/io/ReadCsvTest.cpp index fd68ece99..a28e03d46 100644 --- a/test/runtime/local/io/ReadCsvTest.cpp +++ b/test/runtime/local/io/ReadCsvTest.cpp @@ -18,6 +18,7 @@ #include #include #include +#include #include @@ -57,6 +58,52 @@ TEMPLATE_PRODUCT_TEST_CASE("ReadCsv", TAG_IO, (DenseMatrix), (double)) { DataObjectFactory::destroy(m); } +TEST_CASE("ReadCsv, densematrix of doubles using binary optimization", "[TAG_IO][binOpt]") { + size_t numRows = 2; + size_t numCols = 4; + char filename[] = "test/runtime/local/io/ReadCsv1.csv"; + char delim = ','; + + DenseMatrix *m_new = nullptr; + DenseMatrix *m = nullptr; + + std::string binFile = getDaphneFile(filename); + if (std::filesystem::exists(binFile)) + std::filesystem::remove(binFile); + + readCsv(m_new, filename, numRows, numCols, delim, true); + REQUIRE(std::filesystem::exists(binFile)); + + // Verify dimensions and cell values. + REQUIRE(m_new->getNumRows() == numRows); + REQUIRE(m_new->getNumCols() == numCols); + CHECK(m_new->get(0, 0) == Approx(-0.1)); + CHECK(m_new->get(0, 1) == Approx(-0.2)); + CHECK(m_new->get(0, 2) == Approx(0.1)); + CHECK(m_new->get(0, 3) == Approx(0.2)); + CHECK(m_new->get(1, 0) == Approx(3.14)); + CHECK(m_new->get(1, 1) == Approx(5.41)); + CHECK(m_new->get(1, 2) == Approx(6.22216)); + CHECK(m_new->get(1, 3) == Approx(5)); + + readCsv(m, filename, numRows, numCols, delim, true); + + REQUIRE(m->getNumRows() == numRows); + REQUIRE(m->getNumCols() == numCols); + CHECK(m->get(0, 0) == Approx(-0.1)); + CHECK(m->get(0, 1) == Approx(-0.2)); + CHECK(m->get(0, 2) == Approx(0.1)); + CHECK(m->get(0, 3) == Approx(0.2)); + CHECK(m->get(1, 0) == Approx(3.14)); + CHECK(m->get(1, 1) == Approx(5.41)); + CHECK(m->get(1, 2) == Approx(6.22216)); + CHECK(m->get(1, 3) == Approx(5)); + + DataObjectFactory::destroy(m); + DataObjectFactory::destroy(m_new); + std::filesystem::remove(binFile); +} + TEMPLATE_PRODUCT_TEST_CASE("ReadCsv", TAG_IO, (DenseMatrix), (uint8_t)) { using DT = TestType; DT *m = nullptr; @@ -366,3 +413,225 @@ TEMPLATE_PRODUCT_TEST_CASE("ReadCsv", TAG_IO, (DenseMatrix), (ALL_STRING_VALUE_T DataObjectFactory::destroy(m); } + +// Test case: binary optimization for frame of floats (.daphne expected) +// The first read writes the .daphne file; the second read uses it. +TEST_CASE("ReadCsv, frame of floats using binary optimization", "[TAG_IO][binOpt]") { + ValueTypeCode schema[] = {ValueTypeCode::F64, ValueTypeCode::F64, ValueTypeCode::F64, ValueTypeCode::F64}; + Frame *m_new = nullptr; + Frame *m = nullptr; + size_t numRows = 2; + size_t numCols = 4; + char filename[] = "test/runtime/local/io/ReadCsv1.csv"; + char delim = ','; + + // Remove any existing .daphne file. + std::string binFile = getDaphneFile(filename); + if (std::filesystem::exists(binFile)) + std::filesystem::remove(binFile); + + readCsv(m_new, filename, numRows, numCols, delim, schema, true); + REQUIRE(std::filesystem::exists(binFile)); + + // Verify basic dimensions and cell values. + REQUIRE(m_new->getNumRows() == numRows); + REQUIRE(m_new->getNumCols() == numCols); + CHECK(m_new->getColumn(0)->get(0, 0) == -0.1); + CHECK(m_new->getColumn(1)->get(0, 0) == -0.2); + CHECK(m_new->getColumn(2)->get(0, 0) == 0.1); + CHECK(m_new->getColumn(3)->get(0, 0) == 0.2); + CHECK(m_new->getColumn(0)->get(1, 0) == 3.14); + CHECK(m_new->getColumn(1)->get(1, 0) == 5.41); + CHECK(m_new->getColumn(2)->get(1, 0) == 6.22216); + CHECK(m_new->getColumn(3)->get(1, 0) == 5); + + readCsv(m, filename, numRows, numCols, delim, schema, true); + + // Verify basic dimensions and cell values. + REQUIRE(m->getNumRows() == numRows); + REQUIRE(m->getNumCols() == numCols); + CHECK(m->getColumn(0)->get(0, 0) == -0.1); + CHECK(m->getColumn(1)->get(0, 0) == -0.2); + CHECK(m->getColumn(2)->get(0, 0) == 0.1); + CHECK(m->getColumn(3)->get(0, 0) == 0.2); + CHECK(m->getColumn(0)->get(1, 0) == 3.14); + CHECK(m->getColumn(1)->get(1, 0) == 5.41); + CHECK(m->getColumn(2)->get(1, 0) == 6.22216); + CHECK(m->getColumn(3)->get(1, 0) == 5); + + DataObjectFactory::destroy(m); + DataObjectFactory::destroy(m_new); + std::filesystem::remove(binFile); +} + +// Test case: binary optimization for frame of uint8s (.daphne expected) +TEST_CASE("ReadCsv, frame of uint8s using binary optimization", "[TAG_IO][binOpt]") { + ValueTypeCode schema[] = {ValueTypeCode::UI8, ValueTypeCode::UI8, ValueTypeCode::UI8, ValueTypeCode::UI8}; + Frame *m_new = nullptr; + Frame *m = nullptr; + size_t numRows = 2; + size_t numCols = 4; + char filename[] = "test/runtime/local/io/ReadCsv2.csv"; + char delim = ','; + + std::string binFile = getDaphneFile(filename); + if (std::filesystem::exists(binFile)) + std::filesystem::remove(binFile); + + readCsv(m_new, filename, numRows, numCols, delim, schema, true); + REQUIRE(std::filesystem::exists(binFile)); + + REQUIRE(m_new->getNumRows() == numRows); + REQUIRE(m_new->getNumCols() == numCols); + CHECK(m_new->getColumn(0)->get(0, 0) == 1); + CHECK(m_new->getColumn(1)->get(0, 0) == 2); + CHECK(m_new->getColumn(2)->get(0, 0) == 3); + CHECK(m_new->getColumn(3)->get(0, 0) == 4); + // Negative numbers wrapped around. + CHECK(m_new->getColumn(0)->get(1, 0) == 255); + CHECK(m_new->getColumn(1)->get(1, 0) == 254); + CHECK(m_new->getColumn(2)->get(1, 0) == 253); + CHECK(m_new->getColumn(3)->get(1, 0) == 252); + + readCsv(m, filename, numRows, numCols, delim, schema, true); + + REQUIRE(m->getNumRows() == numRows); + REQUIRE(m->getNumCols() == numCols); + CHECK(m->getColumn(0)->get(0, 0) == 1); + CHECK(m->getColumn(1)->get(0, 0) == 2); + CHECK(m->getColumn(2)->get(0, 0) == 3); + CHECK(m->getColumn(3)->get(0, 0) == 4); + // Negative numbers wrapped around. + CHECK(m->getColumn(0)->get(1, 0) == 255); + CHECK(m->getColumn(1)->get(1, 0) == 254); + CHECK(m->getColumn(2)->get(1, 0) == 253); + CHECK(m->getColumn(3)->get(1, 0) == 252); + + DataObjectFactory::destroy(m); + DataObjectFactory::destroy(m_new); + if (std::filesystem::exists(binFile)) + std::filesystem::remove(binFile); +} + +// Test case: binary optimization for frame of numbers and strings (.daphne expected) +TEST_CASE("ReadCsv, frame of numbers and strings using binary optimization", "[TAG_IO][binOpt]") { + ValueTypeCode schema[] = {ValueTypeCode::UI64, ValueTypeCode::F64, ValueTypeCode::STR, ValueTypeCode::UI64, + ValueTypeCode::F64}; + Frame *m_new = nullptr; + Frame *m = nullptr; + size_t numRows = 6; + size_t numCols = 5; + char filename[] = "test/runtime/local/io/ReadCsv5.csv"; + char delim = ','; + + std::string binFile = getDaphneFile(filename); + if (std::filesystem::exists(binFile)) + std::filesystem::remove(binFile); + + readCsv(m_new, filename, numRows, numCols, delim, schema, true); + // daphne files currently dont support strings + REQUIRE(!std::filesystem::exists(binFile)); + + REQUIRE(m_new->getNumRows() == numRows); + REQUIRE(m_new->getNumCols() == numCols); + // Test several cells along different columns. + CHECK(m_new->getColumn(0)->get(0, 0) == 222); + CHECK(m_new->getColumn(0)->get(1, 0) == 444); + CHECK(m_new->getColumn(0)->get(2, 0) == 555); + CHECK(m_new->getColumn(0)->get(3, 0) == 777); + CHECK(m_new->getColumn(0)->get(4, 0) == 111); + CHECK(m_new->getColumn(0)->get(5, 0) == 222); + CHECK(m_new->getColumn(1)->get(0, 0) == 11.5); + CHECK(m_new->getColumn(1)->get(1, 0) == 19.3); + CHECK(m_new->getColumn(2)->get(0, 0) == "world"); + CHECK(m_new->getColumn(2)->get(1, 0) == "sample,"); + CHECK(m_new->getColumn(3)->get(0, 0) == 444); + CHECK(m_new->getColumn(4)->get(0, 0) == 55.6); + + readCsv(m, filename, numRows, numCols, delim, schema, true); + + REQUIRE(m->getNumRows() == numRows); + REQUIRE(m->getNumCols() == numCols); + // Test several cells along different columns. + CHECK(m->getColumn(0)->get(0, 0) == 222); + CHECK(m->getColumn(0)->get(1, 0) == 444); + CHECK(m->getColumn(0)->get(2, 0) == 555); + CHECK(m->getColumn(0)->get(3, 0) == 777); + CHECK(m->getColumn(0)->get(4, 0) == 111); + CHECK(m->getColumn(0)->get(5, 0) == 222); + CHECK(m->getColumn(1)->get(0, 0) == 11.5); + CHECK(m->getColumn(1)->get(1, 0) == 19.3); + CHECK(m->getColumn(2)->get(0, 0) == "world"); + CHECK(m->getColumn(2)->get(1, 0) == "sample,"); + CHECK(m->getColumn(3)->get(0, 0) == 444); + CHECK(m->getColumn(4)->get(0, 0) == 55.6); + + DataObjectFactory::destroy(m); + DataObjectFactory::destroy(m_new); + std::filesystem::remove(binFile); +} + +// Test case: binary optimization for frame handling INF and NAN (.daphne expected) +TEST_CASE("ReadCsv, frame of INF and NAN parsing using binary optimization", "[TAG_IO][binOpt]") { + ValueTypeCode schema[] = {ValueTypeCode::F64, ValueTypeCode::F64, ValueTypeCode::F64, ValueTypeCode::F64}; + Frame *m_new = nullptr; + Frame *m = nullptr; + size_t numRows = 2; + size_t numCols = 4; + char filename[] = "test/runtime/local/io/ReadCsv3.csv"; + char delim = ','; + + std::string binFile = getDaphneFile(filename); + if (std::filesystem::exists(binFile)) + std::filesystem::remove(binFile); + + readCsv(m_new, filename, numRows, numCols, delim, schema, true); + REQUIRE(std::filesystem::exists(binFile)); + + readCsv(m, filename, numRows, numCols, delim, schema, true); + + for (size_t c = 0; c < numCols; ++c) { + double valNew = m_new->getColumn(c)->get(0, 0); + double val = m->getColumn(c)->get(0, 0); + if (c % 2 == 0) { // first row: INF variations + CHECK(val == valNew); + } else { + // second row should contain NaN values. + CHECK(std::isnan(m_new->getColumn(c)->get(1, 0))); + CHECK(std::isnan(m->getColumn(c)->get(1, 0))); + } + } + + DataObjectFactory::destroy(m); + DataObjectFactory::destroy(m_new); + std::filesystem::remove(binFile); +} + +// Test case: binary optimization with varying columns +TEST_CASE("ReadCsv, frame of varying columns using binary optimization", "[TAG_IO][binOpt]") { + ValueTypeCode schema[] = {ValueTypeCode::SI8, ValueTypeCode::F32}; + Frame *m_new = nullptr; + Frame *m = nullptr; + size_t numRows = 2; + size_t numCols = 2; + char filename[] = "test/runtime/local/io/ReadCsv4.csv"; + char delim = ','; + + std::string binFile = getDaphneFile(filename); + if (std::filesystem::exists(binFile)) + std::filesystem::remove(binFile); + + readCsv(m_new, filename, numRows, numCols, delim, schema, true); + REQUIRE(std::filesystem::exists(binFile)); + + readCsv(m, filename, numRows, numCols, delim, schema, true); + + for (size_t r = 0; r < numRows; r++) { + CHECK(m_new->getColumn(0)->get(r, 0) == m->getColumn(0)->get(r, 0)); + CHECK(m_new->getColumn(1)->get(r, 0) == m->getColumn(1)->get(r, 0)); + } + + DataObjectFactory::destroy(m); + DataObjectFactory::destroy(m_new); + std::filesystem::remove(binFile); +}