@areb0s/scip.js 1.2.2 → 1.2.4

package/dist/index.mjs

@@ -51,6 +51,13 @@ export {
   terminate as terminateWorker
 } from './scip-worker-client.js';
 
+// Callback API (with incumbent/node callbacks support)
+export { 
+  SCIPApi,
+  solveWithCallbacks,
+  Status as ApiStatus
+} from './scip-api-wrapper.js';
+
 // Default export (main thread API)
 import SCIP from './scip-wrapper.js';
 export default SCIP;
@@ -71,3 +78,26 @@ export async function createWorkerSolver(options = {}) {
     terminate: worker.terminate
   };
 }
+
+/**
+ * Create a callback-enabled solver instance
+ * Use this when you need incumbent callbacks for custom pruning logic
+ * 
+ * @example
+ * const solver = await createCallbackSolver();
+ * solver.onIncumbent((objValue) => {
+ *   console.log('New best solution:', objValue);
+ * });
+ * const result = await solver.solve(problem, {
+ *   format: 'zpl',
+ *   initialSolution: { x: 1, y: 0 },
+ *   cutoff: 100
+ * });
+ * solver.destroy();
+ */
+export async function createCallbackSolver(options = {}) {
+  const { SCIPApi } = await import('./scip-api-wrapper.js');
+  const solver = new SCIPApi();
+  await solver.init(options);
+  return solver;
+}

package/dist/scip-api-wrapper.js

@@ -0,0 +1,366 @@
+/**
+ * SCIP.js API Mode - With Callback Support
+ * 
+ * This module provides a callback-enabled interface to SCIP.
+ * Unlike the CLI mode, this allows:
+ * - Setting initial solutions (warm start)
+ * - Receiving callbacks when new incumbents are found
+ * - Setting cutoff bounds for pruning
+ * 
+ * Usage:
+ *   import { SCIPApi } from './scip-api-wrapper.js';
+ *   
+ *   const scip = new SCIPApi();
+ *   await scip.init();
+ *   
+ *   // Set callback for new solutions
+ *   scip.onIncumbent((objValue) => {
+ *     console.log('New solution found:', objValue);
+ *   });
+ *   
+ *   // Solve with initial solution hint
+ *   const result = await scip.solve(problemZPL, {
+ *     format: 'zpl',
+ *     initialSolution: { x: 1, y: 0 },
+ *     cutoff: 100  // Prune nodes worse than this
+ *   });
+ */
+
+let scipApiModule = null;
+let isApiInitialized = false;
+let apiInitPromise = null;
+
+/**
+ * Default CDN base URL
+ */
+const DEFAULT_CDN_BASE = "https://cdn.jsdelivr.net/npm/@areb0s/scip.js@latest/dist/";
+
+/**
+ * Check if running in Node.js
+ */
+function isNode() {
+  return typeof process !== 'undefined' && 
+         process.versions != null && 
+         process.versions.node != null;
+}
+
+/**
+ * Get base URL
+ */
+function getBaseUrl() {
+  const globalScope =
+    (typeof globalThis !== "undefined" && globalThis) ||
+    (typeof self !== "undefined" && self) ||
+    (typeof window !== "undefined" && window) ||
+    {};
+
+  if (globalScope.SCIP_BASE_URL) {
+    return globalScope.SCIP_BASE_URL;
+  }
+
+  if (typeof __importMetaUrl !== "undefined" && __importMetaUrl && !__importMetaUrl.startsWith("blob:")) {
+    return __importMetaUrl.substring(0, __importMetaUrl.lastIndexOf("/") + 1);
+  }
+
+  return DEFAULT_CDN_BASE;
+}
+
+/**
+ * Resolve WASM path for both Node.js and browser
+ */
+async function resolveWasmPath(inputPath) {
+  if (isNode()) {
+    const { isAbsolute } = await import('path');
+    
+    // If already absolute, return as-is
+    if (isAbsolute(inputPath)) {
+      return inputPath;
+    }
+    
+    // For Node.js, resolve relative paths to absolute file path
+    const { fileURLToPath } = await import('url');
+    const { dirname, resolve } = await import('path');
+    
+    // Get the directory of this module
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    
+    // Resolve relative to this module
+    return resolve(__dirname, inputPath);
+  }
+  // For browser, return URL as-is
+  return inputPath;
+}
+
+/**
+ * Solution status enum
+ */
+export const Status = {
+  OPTIMAL: "optimal",
+  INFEASIBLE: "infeasible",
+  UNBOUNDED: "unbounded",
+  TIME_LIMIT: "timelimit",
+  UNKNOWN: "unknown",
+  ERROR: "error",
+};
+
+/**
+ * SCIP API class with callback support
+ */
+export class SCIPApi {
+  constructor() {
+    this._module = null;
+    this._incumbentCallback = null;
+    this._nodeCallback = null;
+    this._isInitialized = false;
+  }
+
+  /**
+   * Initialize SCIP API module
+   */
+  async init(options = {}) {
+    if (this._isInitialized) {
+      return;
+    }
+
+    const baseUrl = getBaseUrl();
+    let wasmPath = options.wasmPath || baseUrl + "scip-api.wasm";
+    
+    // Resolve WASM path for Node.js
+    wasmPath = await resolveWasmPath(wasmPath);
+
+    // Dynamic import of the API module
+    const createSCIPAPI = (await import("./scip-api.js")).default;
+
+    // Build module options
+    const moduleOptions = {
+      locateFile: (path) => {
+        if (path.endsWith(".wasm")) {
+          return wasmPath;
+        }
+        // For other files, resolve relative to base URL
+        if (isNode()) {
+          return wasmPath.replace(/scip-api\.wasm$/, path);
+        }
+        return baseUrl + path;
+      }
+    };
+
+    // For Node.js, provide instantiateWasm to load WASM from file
+    if (isNode()) {
+      const { readFileSync } = await import('fs');
+      moduleOptions.wasmBinary = readFileSync(wasmPath);
+    }
+
+    this._module = await createSCIPAPI(moduleOptions);
+
+    // Create SCIP instance
+    const created = this._module._scip_create();
+    if (!created) {
+      throw new Error("Failed to create SCIP instance");
+    }
+
+    // Setup callbacks
+    this._module.onIncumbent = (objValue) => {
+      if (this._incumbentCallback) {
+        this._incumbentCallback(objValue);
+      }
+    };
+
+    this._module.onNode = (dualBound, primalBound, nodes) => {
+      if (this._nodeCallback) {
+        this._nodeCallback({ dualBound, primalBound, nodes });
+      }
+    };
+
+    // Create virtual filesystem directories
+    try { this._module.FS.mkdir("/problems"); } catch (e) { /* exists */ }
+    try { this._module.FS.mkdir("/solutions"); } catch (e) { /* exists */ }
+
+    this._isInitialized = true;
+  }
+
+  /**
+   * Set callback for new incumbent solutions
+   * @param {Function} callback - (objValue: number) => void
+   */
+  onIncumbent(callback) {
+    this._incumbentCallback = callback;
+    if (this._module) {
+      this._module._scip_enable_incumbent_callback(callback ? 1 : 0);
+    }
+  }
+
+  /**
+   * Set callback for node processing (for progress tracking)
+   * @param {Function} callback - ({dualBound, primalBound, nodes}) => void
+   */
+  onNode(callback) {
+    this._nodeCallback = callback;
+    if (this._module) {
+      this._module._scip_enable_node_callback(callback ? 1 : 0);
+    }
+  }
+
+  /**
+   * Solve an optimization problem
+   * @param {string} problem - Problem definition
+   * @param {Object} options - Solver options
+   * @param {string} options.format - 'lp', 'mps', 'zpl', 'cip'
+   * @param {number} options.timeLimit - Time limit in seconds
+   * @param {number} options.gap - Relative gap tolerance
+   * @param {Object} options.initialSolution - Initial solution hint {varName: value}
+   * @param {number} options.cutoff - Cutoff bound for pruning
+   * @returns {Promise<Object>} Solution
+   */
+  async solve(problem, options = {}) {
+    if (!this._isInitialized) {
+      await this.init(options);
+    }
+
+    const {
+      format = "lp",
+      timeLimit = 3600,
+      gap = null,
+      initialSolution = null,
+      cutoff = null,
+    } = options;
+
+    // Reset for new problem
+    this._module._scip_reset();
+
+    // Write problem file
+    const formatExtMap = { mps: "mps", zpl: "zpl", cip: "cip", lp: "lp" };
+    const ext = formatExtMap[format] || "lp";
+    const problemFile = `/problems/problem.${ext}`;
+    this._module.FS.writeFile(problemFile, problem);
+
+    // Read problem
+    const problemFilePtr = this._module.allocateUTF8(problemFile);
+    const readOk = this._module._scip_read_problem(problemFilePtr);
+    this._module._free(problemFilePtr);
+
+    if (!readOk) {
+      return {
+        status: Status.ERROR,
+        error: "Failed to read problem",
+      };
+    }
+
+    // Set parameters
+    this._module._scip_set_time_limit(timeLimit);
+
+    if (gap !== null) {
+      this._module._scip_set_gap(gap);
+    }
+
+    if (cutoff !== null) {
+      this._module._scip_set_cutoff(cutoff);
+    }
+
+    // Add initial solution hint
+    if (initialSolution !== null) {
+      const solutionStr = Object.entries(initialSolution)
+        .map(([name, value]) => `${name}=${value}`)
+        .join(";");
+      
+      const solutionPtr = this._module.allocateUTF8(solutionStr);
+      this._module._scip_add_solution_hint(solutionPtr);
+      this._module._free(solutionPtr);
+    }
+
+    // Enable callbacks if registered
+    this._module._scip_enable_incumbent_callback(this._incumbentCallback ? 1 : 0);
+    this._module._scip_enable_node_callback(this._nodeCallback ? 1 : 0);
+
+    // Solve
+    const statusCode = this._module._scip_solve();
+
+    // Map status
+    const statusMap = {
+      0: Status.OPTIMAL,
+      1: Status.INFEASIBLE,
+      2: Status.UNBOUNDED,
+      3: Status.TIME_LIMIT,
+      4: Status.UNKNOWN,
+      [-1]: Status.ERROR,
+    };
+    const status = statusMap[statusCode] || Status.UNKNOWN;
+
+    // Get results
+    const objective = this._module._scip_get_objective();
+    const solvingTime = this._module._scip_get_solving_time();
+    const nodes = this._module._scip_get_nnodes();
+    const finalGap = this._module._scip_get_gap();
+    const dualBound = this._module._scip_get_dual_bound();
+    const primalBound = this._module._scip_get_primal_bound();
+
+    // Get variable values
+    const variables = {};
+    const varNamesPtr = this._module._scip_get_var_names();
+    const varNamesStr = this._module.UTF8ToString(varNamesPtr);
+    
+    if (varNamesStr) {
+      const varNames = varNamesStr.split(",");
+      for (const name of varNames) {
+        if (name) {
+          const namePtr = this._module.allocateUTF8(name);
+          variables[name] = this._module._scip_get_var_value(namePtr);
+          this._module._free(namePtr);
+        }
+      }
+    }
+
+    // Cleanup
+    try { this._module.FS.unlink(problemFile); } catch (e) { /* ignore */ }
+
+    return {
+      status,
+      objective,
+      variables,
+      statistics: {
+        solvingTime,
+        nodes,
+        gap: finalGap,
+        dualBound,
+        primalBound,
+      },
+    };
+  }
+
+  /**
+   * Free SCIP resources
+   */
+  destroy() {
+    if (this._module) {
+      this._module._scip_free();
+      this._module = null;
+      this._isInitialized = false;
+    }
+  }
+}
+
+/**
+ * Convenience function - solve with callbacks
+ */
+export async function solveWithCallbacks(problem, options = {}) {
+  const scip = new SCIPApi();
+  
+  try {
+    await scip.init(options);
+
+    if (options.onIncumbent) {
+      scip.onIncumbent(options.onIncumbent);
+    }
+
+    if (options.onNode) {
+      scip.onNode(options.onNode);
+    }
+
+    return await scip.solve(problem, options);
+  } finally {
+    scip.destroy();
+  }
+}
+
+export default SCIPApi;