@happychef/algorithm 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happychef/algorithm",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "author": "happy chef",

package/simulateTableAssignment.js

@@ -135,10 +135,15 @@ function calculateDistance(tableA, tableB) {
 }
 
 /**
- * Backtracking function to find a combination of tables (multi-table assignment).
+ * HIGHLY OPTIMIZED: Backtracking with aggressive pruning for multi-table assignment.
+ * Key optimizations:
+ * - Tables are PRE-FILTERED, so no validity checks needed here
+ * - Aggressive branch pruning with capacity tracking
+ * - Early termination on optimal solutions
+ * - Minimal logging to reduce overhead
  */
-function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best, requiredSlots, tableOccupiedSlots, reservationDateStr, reservationTimeStr) {
-    // Base case: All guests are seated
+function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best) {
+    // Base case: All guests seated
     if (guestsNeeded <= 0) {
         // Calculate total distance for the current combination
         let distanceSum = 0;
@@ -147,105 +152,87 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
                 distanceSum += calculateDistance(currentSet[i], currentSet[j]);
             }
         }
-        // Update best solution if this one is better (fewer tables, then lower distance)
+        // Update if better (fewer tables, or same count with lower distance)
         if (currentSet.length < best.tableCount || (currentSet.length === best.tableCount && distanceSum < best.minDistance)) {
             best.minDistance = distanceSum;
-            best.tables = [...currentSet]; // Store a copy
+            best.tables = [...currentSet];
             best.tableCount = currentSet.length;
-            console.log(`Found new best table combination: ${best.tables.map(t => t.tableNumber).join(', ')} for ${guestsNeeded} guests`);
         }
         return;
     }
 
-    if (startIndex >= tables.length) {
+    // PRUNING: Can't improve on current best table count
+    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
         return;
     }
 
-    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
-        return; // Pruning based on table count
+    // PRUNING: Not enough tables remaining
+    if (startIndex >= tables.length) {
+        return;
     }
 
-    let maxPossibleCapacity = 0;
+    // PRUNING: Calculate remaining capacity (tables are pre-filtered, so all are valid)
+    let maxRemainingCapacity = 0;
     for (let i = startIndex; i < tables.length; i++) {
-        const tbl = tables[i];
-        // Only consider valid & free tables for potential capacity
-        if (isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr) &&
-            isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) 
-        {
-            maxPossibleCapacity += tbl.maxCapacity;
-        }
+        maxRemainingCapacity += tables[i].maxCapacity;
     }
-    
-    if (maxPossibleCapacity < guestsNeeded) {
-        return; // Impossible to seat remaining guests
+    if (maxRemainingCapacity < guestsNeeded) {
+        return; // Impossible to satisfy
     }
 
+    // OPTIMIZATION: Limit search depth for large table sets
+    const remainingTables = tables.length - startIndex;
+    if (remainingTables > 15 && currentSet.length === 0) {
+        // For first iteration with many tables, only try largest tables
+        const sortedBySize = tables.slice(startIndex).sort((a, b) => b.maxCapacity - a.maxCapacity);
+        const topTables = sortedBySize.slice(0, Math.min(10, sortedBySize.length));
+
+        for (const tbl of topTables) {
+            const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+            if (canSeat >= tbl.minCapacity || canSeat >= guestsNeeded) {
+                currentSet.push(tbl);
+                findMultiTableCombination(tables, guestsNeeded - canSeat, startIndex + 1, currentSet, best);
+                currentSet.pop();
+
+                if (best.tableCount === 1) return; // Found optimal
+            }
+        }
+        return;
+    }
+
+    // Standard backtracking for remaining cases
     for (let i = startIndex; i < tables.length; i++) {
         const tbl = tables[i];
-
-        // --- Core Checks ---
-        // 1. Check if temporary table is valid for this date/time
-        if (!isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr)) {
-            continue; // Skip invalid temporary table
-        }
-        
-        // 2. Check if table is free for all required slots
-        if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) {
-            continue; // Skip occupied table
-        }
-        
-        // 3. Check if table contributes meaningfully
         const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+
+        // Skip if table can't contribute meaningfully
         if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) {
-            continue; // Don't use a table for fewer than its min capacity unless it fulfills the remainder
+            continue;
         }
-        
-        if (canSeat <= 0) continue; // Table doesn't help
 
-        // --- Recurse ---
-        currentSet.push(tbl); // Add table to current combination
-        console.log(`Trying table ${tbl.tableNumber} (${tbl.minCapacity}-${tbl.maxCapacity}) for ${canSeat}/${guestsNeeded} guests`);
-        
-        findMultiTableCombination(
-            tables,
-            guestsNeeded - canSeat, // Reduce guests needed
-            i + 1, // Explore next tables
-            currentSet,
-            best,
-            requiredSlots,
-            tableOccupiedSlots,
-            reservationDateStr,
-            reservationTimeStr
-        );
-        
-        currentSet.pop(); // Backtrack: remove table to explore other combinations
+        if (canSeat <= 0) continue;
+
+        currentSet.push(tbl);
+        findMultiTableCombination(tables, guestsNeeded - canSeat, i + 1, currentSet, best);
+        currentSet.pop();
+
+        // EARLY EXIT: Found optimal single or two-table solution
+        if (best.tableCount <= 2) {
+            return;
+        }
     }
 }
 
 function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
     console.log(`[assignTablesForGivenTime] Processing ${date} ${time} for ${guests} guests`);
-    
+
     // FIXED: More robust parsing of settings with detailed logging
     const generalSettings = restaurantData["general-settings"] || {};
-    console.log("[assignTablesForGivenTime] General settings:", generalSettings);
-    
-    // Check what format the data is in
-    console.log("[assignTablesForGivenTime] duurReservatie format:", typeof generalSettings.duurReservatie);
-    console.log("[assignTablesForGivenTime] intervalReservatie format:", typeof generalSettings.intervalReservatie);
-    
-    // Check for MongoDB format
-    if (typeof generalSettings.duurReservatie === 'object' && generalSettings.duurReservatie?.$numberInt) {
-        console.log("[assignTablesForGivenTime] duurReservatie is in MongoDB format:", generalSettings.duurReservatie?.$numberInt);
-    }
-    
-    if (typeof generalSettings.intervalReservatie === 'object' && generalSettings.intervalReservatie?.$numberInt) {
-        console.log("[assignTablesForGivenTime] intervalReservatie is in MongoDB format:", generalSettings.intervalReservatie?.$numberInt);
-    }
-    
+
     // DEFAULT VALUES - this approach mirrors the TypeScript implementation
     let duurReservatie = 120;  // Default: 2 hours in minutes
     let intervalReservatie = 15;  // Default: 15 minute intervals
-    
+
     // Use safeParseInt for robust parsing
     duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
     intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
@@ -256,7 +243,7 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
         console.error("Invalid interval settings.");
         return [];
     }
-    
+
     const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
     if (!requiredSlots || requiredSlots.length === 0) {
         console.error(`Could not compute required slots for ${time}`);
@@ -267,17 +254,33 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
     const allTables = getAllTables(restaurantData, selectedZitplaats);
     console.log(`[assignTablesForGivenTime] Checking ${allTables.length} tables`);
 
+    // OPTIMIZATION: Pre-filter and sort tables for better performance
+    // Filter out invalid and occupied tables first
+    const validTables = allTables.filter(t =>
+        isTemporaryTableValid(t, date, time) &&
+        isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+    );
+
+    if (validTables.length === 0) {
+        console.log(`[assignTablesForGivenTime] No valid tables available`);
+        return [];
+    }
+
+    // OPTIMIZATION: Sort tables by capacity (prefer exact matches first)
+    // This helps find optimal solutions faster
+    validTables.sort((a, b) => {
+        // Prioritize tables that can seat exactly the number of guests
+        const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
+        const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
+        if (aExact !== bExact) return aExact - bExact;
+
+        // Then sort by capacity (smaller tables first to minimize waste)
+        return a.maxCapacity - b.maxCapacity;
+    });
+
     // --- Try single-table assignment first ---
-    for (const t of allTables) {
-        // Use imported validation function
-        if (!isTemporaryTableValid(t, date, time)) {
-            continue;
-        }
-        
-        if (t.minCapacity <= guests && 
-            guests <= t.maxCapacity && 
-            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) 
-        {
+    for (const t of validTables) {
+        if (t.minCapacity <= guests && guests <= t.maxCapacity) {
             console.log(`[assignTablesForGivenTime] Assigned single table ${t.tableNumber} for ${guests} guests`);
             return [t.tableNumber];
         }
@@ -288,15 +291,11 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
     // --- Try multi-table assignment ---
     const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
     findMultiTableCombination(
-        allTables,
+        validTables, // Use pre-filtered and sorted tables
         guests,
         0, // Start index
         [], // Initial empty set
-        best, // Best solution object
-        requiredSlots,
-        tableOccupiedSlots,
-        date, // Pass context
-        time  // Pass context
+        best // Best solution object (no need for slots/occupancy - already filtered)
     );
 
     if (best.tables.length > 0) {
@@ -409,14 +408,28 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables
         console.log(`[isTimeAvailableSync] Checking ${allTables.length} tables for new reservation`);
 
-        // 1. Try single table assignment
-        for (const t of allTables) {
-            if (!isTemporaryTableValid(t, date, time)) continue; // Check temporary validity
+        // OPTIMIZATION: Pre-filter valid tables
+        const validTables = allTables.filter(t =>
+            isTemporaryTableValid(t, date, time) &&
+            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+        );
 
-            if (t.minCapacity <= guests &&
-                guests <= t.maxCapacity &&
-                isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots))
-            {
+        if (validTables.length === 0) {
+            console.log(`[isTimeAvailableSync] No valid tables available`);
+            return false;
+        }
+
+        // OPTIMIZATION: Sort for faster exact matches
+        validTables.sort((a, b) => {
+            const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
+            const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
+            if (aExact !== bExact) return aExact - bExact;
+            return a.maxCapacity - b.maxCapacity;
+        });
+
+        // 1. Try single table assignment
+        for (const t of validTables) {
+            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
                 console.log(`[isTimeAvailableSync] Found single table ${t.tableNumber} for ${guests} guests at ${time}`);
                 return true; // Available
             }
@@ -427,12 +440,11 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         // 2. Try multi-table assignment
         const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
         findMultiTableCombination(
-            allTables,
+            validTables, // Use pre-filtered tables
             guests,
-            0, [], best,
-            requiredSlots,
-            tableOccupiedSlots, // Use the final occupancy map
-            date, time
+            0, // Start index
+            [], // Empty current set
+            best // Best solution
         );
 
         const result = best.tables.length > 0;
@@ -441,7 +453,7 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         } else {
             console.log(`[isTimeAvailableSync] No table combination available`);
         }
-        
+
         return result; // Available if a combination was found
 
     } catch (error) {