main.py

import pathlib
import sys
import time
from pathlib import Path
from setup_problem import batch_generate
from knapsack import knapsack

if __name__ == "__main__":
    if len(sys.argv) < 1:
        print(f"Usage: {sys.argv[0]} [parameter_file] [exclude_baseline]")
        sys.exit(1)

    input_path = Path(sys.argv[1]) if len(sys.argv) >= 2 else Path.cwd() / "parameters"
    json_files = []

    if input_path.is_file():
        json_files = [input_path]
    elif input_path.is_dir():
        json_files = sorted(list(input_path.glob("*.json")))
    else:
        input_path.mkdir(parents=True, exist_ok=True)

    with open("results.txt", "a+", encoding="utf-8") as f:
        f.seek(0)
        content = f.read()
        existing_recursive_results_count = content.count("| R |")
        existing_recursive_td_results_count = content.count("| RTD |")
        existing_iterative_bu_results_count = content.count("| IBU |")
        existing_iterative_bu_opt_results_count = content.count("| IBUOPT |")
        existing_bnb_results_count = content.count("| BNB |")

        if len(sys.argv) >= 3:
            skip_recursive = True
            skip_recursive_td = True
            skip_iterative_bu = True
            print("Skipping recursive baseline for more complex knapsack problems resolution")
            if not json_files:
                print(f"Directory {input_path} is empty. Generating instances...")
                input_path.mkdir(parents=True, exist_ok=True)
                batch_generate(
                    n_instances=15,
                    parameters_seed=42,
                    max_capacity=100000,
                    max_profit=100,
                    max_weight=100,
                    nb_items=200,
                    output_dir=input_path)
                json_files = sorted(list(input_path.glob("*.json")))
        else:
            skip_recursive = (existing_recursive_results_count >= len(json_files))
            skip_recursive_td = (existing_recursive_td_results_count >= len(json_files))
            skip_iterative_bu = (existing_iterative_bu_results_count >= len(json_files))
            if not json_files:
                print(f"Directory {input_path} is empty. Generating instances for problem with baseline computation...")
                input_path.mkdir(parents=True, exist_ok=True)
                batch_generate(n_instances=15, parameters_seed=42, output_dir=input_path)
                json_files = sorted(list(input_path.glob("*.json")))

        skip_iterative_bu_opt = (existing_iterative_bu_opt_results_count >= len(json_files))
        skip_bnb = (existing_bnb_results_count >= len(json_files))

        if json_files is not None:
            for json_file in json_files:
                time.sleep(0.1)
                if not skip_recursive:
                    print(f"Treating knapsack problem recursively for parameters in {json_file}")

                    solution, capacity_left, metrics = knapsack(json_file, "recursive")
                    f.write(
                        f"Parameters file: {json_file.name} | R | Solution: {solution} of profit, {capacity_left} of "
                        f"capacity left | {metrics}")
                    f.flush()  # Ensure data is written to disk immediately
                    time.sleep(0.1)  # Prevent thermal noise

                time.sleep(0.1)
                if not skip_recursive_td:
                    print(f"Treating knapsack problem recursively with Top-Down design for parameters in {json_file}")

                    solution, capacity_left, metrics = knapsack(json_file, "recursive_td")
                    f.write(
                        f"Parameters file: {json_file.name} | RTD | Solution: {solution} of profit, {capacity_left} of "
                        f"capacity left | {metrics}")
                    f.flush()  # Ensure data is written to disk immediately
                    time.sleep(0.1)  # Prevent thermal noise

                time.sleep(0.1)
                if not skip_iterative_bu:
                    print(f"Treating knapsack problem iteratively with Bottom-Up design for parameters in {json_file}")

                    solution, capacity_left, metrics = knapsack(json_file, "iterative_bu")
                    f.write(
                        f"Parameters file: {json_file.name} | IBU | Solution: {solution} of profit, {capacity_left} of "
                        f"capacity left | {metrics}")
                    f.flush()  # Ensure data is written to disk immediately
                    time.sleep(0.1)  # Prevent thermal noise

                time.sleep(0.1)
                if not skip_iterative_bu_opt:
                    print(f"Treating knapsack problem iteratively with Bottom-Up design space optimized, "
                          f"for parameters in {json_file}")

                    solution, capacity_left, metrics = knapsack(json_file, "iterative_bu_opt")
                    f.write(
                        f"Parameters file: {json_file.name} | IBUOPT | Solution: {solution} of profit, {capacity_left} "
                        f"of capacity left | {metrics}")
                    f.flush()  # Ensure data is written to disk immediately
                    time.sleep(0.1)  # Prevent thermal noise

                time.sleep(0.1)
                if not skip_bnb:
                    print(f"Treating knapsack problem with branch and bound logic, "
                          f"for parameters in {json_file}")

                    solution, capacity_left, metrics = knapsack(json_file, "bnb")
                    f.write(
                        f"Parameters file: {json_file.name} | BNB | Solution: {solution} of profit, {capacity_left} "
                        f"of capacity left | {metrics}")
                    f.flush()  # Ensure data is written to disk immediately
                    time.sleep(0.1)  # Prevent thermal noise

            if skip_recursive:
                print(f"Skipped recursive : {existing_recursive_results_count} results already found in "
                      f"results.txt.")
            if skip_recursive_td:
                print(f"Skipped recursive Top-Down : {existing_recursive_td_results_count} results already found in "
                      f"results.txt.")
            if skip_iterative_bu:
                print(f"Skipped iterative Bottom-Up : {existing_recursive_td_results_count} results already found in "
                      f"results.txt.")
            if skip_iterative_bu_opt:
                print(f"Skipped iterative Bottom-Up space optimized : {existing_recursive_td_results_count} results "
                      f"already found in results.txt.")
            if skip_bnb:
                print(f"Skipped Branch and bound : {existing_bnb_results_count} results already found in "
                      f"results.txt.")