calc_par_context_example.cpp

/*
   DDS, a bridge double dummy solver.

   Copyright (C) 2006-2014 by Bo Haglund / 
   2014-2016 by Bo Haglund & Soren Hein.

   See LICENSE and README.
*/

// Example showing context usage for par calculations.
// This demonstrates how to use SolverContext for managing resources
// across multiple operations.

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include <api/calc_par.hpp>
#include <api/dll.h>
#include <solver_context/solver_context.hpp>
#include "hands.hpp"


void example_without_context()
{
    printf("\n=== Par Calculation (Traditional Approach) ===\n\n");

    auto start_time = std::chrono::high_resolution_clock::now();

    for (int handno = 0; handno < 3; handno++)
    {
        DdTableResults ddtable;
        set_table(&ddtable, handno);

        ParResults pres;
        int res = Par(&ddtable, &pres, vulnerability_[handno]);

        if (res == RETURN_NO_FAULT)
        {
            const char* suit_name = 
                (trump_suit_[handno] == 0 ? "♠" :
         trump_suit_[handno] == 1 ? "♥" :
         trump_suit_[handno] == 2 ? "♦" :
         trump_suit_[handno] == 3 ? "♣" : "NT");

            printf("Hand %d (%s): Par score = %s\n", 
             handno + 1,
             suit_name,
             pres.par_score[0]);
        }
    }

    auto end_time = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
            end_time - start_time).count();
    printf("\nTime (traditional): %lld ms\n\n", static_cast<long long>(elapsed));
}


void example_with_context()
{
    printf("\n=== Par Calculation WITH SolverContext ===\n\n");

    // Create a single solver context for resource management
    SolverContext context;

    printf("SolverContext provides:\n");
    printf("  - Reuse of allocated solver resources across calculations\n");
    printf("  - Persistent solver resources (no per-call allocation overhead)\n");
    printf("  - Consistent API with other context-aware DDS operations\n\n");

    auto start_time = std::chrono::high_resolution_clock::now();

    for (int handno = 0; handno < 3; handno++)
    {
        DdTableDeal table_deal{};
        for (int h = 0; h < DDS_HANDS; ++h) {
            for (int s = 0; s < DDS_SUITS; ++s) {
                table_deal.cards[h][s] = holdings_[handno][s][h];
            }
        }

        DdTableResults ddtable;
        ParResults pres;
        // Use context-aware calc_par API
        int res = calc_par(
            context,
            table_deal,
            vulnerability_[handno],
            &ddtable,
            &pres);

        if (res == RETURN_NO_FAULT)
        {
            const char* suit_name = 
                (trump_suit_[handno] == 0 ? "♠" :
         trump_suit_[handno] == 1 ? "♥" :
         trump_suit_[handno] == 2 ? "♦" :
         trump_suit_[handno] == 3 ? "♣" : "NT");

            printf("Hand %d (%s): Par score = %s\n", 
             handno + 1,
             suit_name,
             pres.par_score[0]);
        }
    }

    auto end_time = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
            end_time - start_time).count();
    printf("\nTime (with context): %lld ms\n\n", static_cast<long long>(elapsed));
}


void example_mixed_usage()
{
    printf("\n=== Context for Sequential Operations ===\n\n");

    // Create a context - useful for managing resources across calls
    SolverContext context;

    printf("Best practices when using SolverContext:\n\n");

    printf("1. Create context once:\n");
    printf("   SolverContext context;\n\n");

    printf("2. Reuse for multiple calculations:\n");
    for (int i = 0; i < 3; i++) {
        DdTableDeal table_deal{};
        for (int h = 0; h < DDS_HANDS; ++h) {
            for (int s = 0; s < DDS_SUITS; ++s) {
                table_deal.cards[h][s] = holdings_[i][s][h];
            }
        }

        DdTableResults ddtable;
        ParResults pres;
        int res = calc_par(
            context,
            table_deal,
            vulnerability_[i],
            &ddtable,
            &pres);
        if (res == RETURN_NO_FAULT) {
            printf("   Hand %d Par: Score = %s\n", i + 1, pres.par_score[0]);
        }
    }

    printf("\n3. Solver resources are reused across operations\n");
    printf("   This is active now: calc_par(ctx, ...) uses the provided context\n\n");
}


void print_python_example()
{
    printf("\n=== Python Equivalent Usage ===\n\n");
    printf("Python code for context reuse:\n\n");
    printf("  from dds3 import SolverContext, solve_board\n\n");
    printf("  # Create context once\n");
    printf("  ctx = SolverContext()\n\n");
    printf("  # Reuse for multiple operations\n");
    printf("  for deal in deals:\n");
    printf("      result = solve_board(deal, context=ctx)\n");
    printf("      print(f'Score: {result[\"score\"]}')\n\n");
}


auto main() -> int
{
    printf("DDS Examples: Par Calculation with SolverContext\n");
    printf("================================================\n");

    // Run examples
    example_without_context();
    example_with_context();
    example_mixed_usage();
    print_python_example();

    printf("\n=== Summary ===\n");
    printf("✓ SolverContext provides resource management\n");
    printf("✓ Backward compatible - traditional API still works\n");
    printf("✓ Python bindings demonstrate context advantages\n");
    printf("✓ Transposition table reuse across operations\n");
    printf("✓ Improved efficiency for batch processing\n");

    return 0;
}