@areb0s/scip.js 1.1.4 → 1.1.5

package/dist/scip-wrapper.js

@@ -88,29 +88,32 @@ function parseStatus(output) {
 
 /**
  * Parse solution values from SCIP output
+ * @param {string} output - stdout from SCIP
+ * @param {string} rawSolution - solution file content (more reliable)
  */
-function parseSolution(output) {
+function parseSolution(output, rawSolution = null) {
   const variables = {};
   const objective = { value: null, sense: null };
   
+  // Use rawSolution if available (more reliable)
+  const solText = rawSolution || output;
+  
   // Parse objective value
-  const objMatch = output.match(/objective value:\s*([\d.e+-]+)/i);
+  const objMatch = solText.match(/objective value:\s*([\d.e+-]+)/i);
   if (objMatch) {
     objective.value = parseFloat(objMatch[1]);
   }
   
   // Parse variable values from solution display
-  // Format: variable_name    value    (obj:coef)
-  const varRegex = /^(\w+)\s+([\d.e+-]+)/gm;
+  // Match ZIMPL-style variable names: x$sun#0, effSum$star#1, b_sun_10, etc.
+  // Format: variableName    value    (obj:coef)
+  const varRegex = /^([\w$#]+)\s+([\d.e+-]+)/gm;
   let match;
   
-  // Look for solution section
-  const solSection = output.split('solution:')[1] || output;
-  
-  while ((match = varRegex.exec(solSection)) !== null) {
+  while ((match = varRegex.exec(solText)) !== null) {
     const name = match[1];
     const value = parseFloat(match[2]);
-    if (!isNaN(value) && name !== 'objective') {
+    if (!isNaN(value) && name !== 'objective' && name !== 'solution') {
       variables[name] = value;
     }
   }
@@ -329,12 +332,7 @@ export async function solve(problem, options = {}) {
     // Run SCIP with batch mode
     const exitCode = scipModule.callMain(['-b', '/settings/commands.txt']);
     
-    // Parse results
-    const status = parseStatus(stdout);
-    const { variables, objective } = parseSolution(stdout);
-    const statistics = parseStatistics(stdout);
-    
-    // Try to read solution file
+    // Try to read solution file first (more reliable for parsing)
     let rawSolution = null;
     try {
       rawSolution = scipModule.FS.readFile(solutionFile, { encoding: 'utf8' });
@@ -342,6 +340,11 @@ export async function solve(problem, options = {}) {
       // Solution file may not exist if infeasible
     }
     
+    // Parse results
+    const status = parseStatus(stdout);
+    const { variables, objective } = parseSolution(stdout, rawSolution);
+    const statistics = parseStatistics(stdout);
+    
     return {
       status,
       objective: objective.value,

package/dist/scip.js

@@ -1,4 +1,28 @@
 
+/**
+ * SCIP.js Browser Bundle
+ * Supports: LP, MIP, MINLP (Mixed Integer Nonlinear Programming)
+ */
+(function(global) {
+  'use strict';
+  
+  // Script directory detection for WASM loading
+  var __SCIP_SCRIPT_DIR__ = (function() {
+    // Check for explicit SCIP_BASE_URL
+    if (typeof SCIP_BASE_URL !== 'undefined' && SCIP_BASE_URL) {
+      return SCIP_BASE_URL + (SCIP_BASE_URL.endsWith('/') ? '' : '/');
+    }
+    // Try to detect from current script
+    if (typeof document !== 'undefined' && document.currentScript && document.currentScript.src) {
+      var src = document.currentScript.src;
+      return src.substring(0, src.lastIndexOf('/') + 1);
+    }
+    // Default CDN (npm)
+    return 'https://cdn.jsdelivr.net/npm/@areb0s/scip.js@latest/dist/';
+  })();
+
+  // Inline the transformed scip-core.js (createSCIP factory function)
+  
 /**
  * SCIP.js Browser Bundle
  * Supports: LP, MIP, MINLP (Mixed Integer Nonlinear Programming)
@@ -322,4 +346,291 @@ var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;Module["ready"]=
     console.error('[SCIP.js] Auto-initialization failed:', err.message);
   });
   
+})(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : globalThis);
+
+  
+  // SCIP wrapper implementation
+  var scipModule = null;
+  var isInitialized = false;
+  var initPromise = null;
+  var readyResolve = null;
+  var readyReject = null;
+  
+  var readyPromise = new Promise(function(resolve, reject) {
+    readyResolve = resolve;
+    readyReject = reject;
+  });
+  
+  var Status = {
+    OPTIMAL: 'optimal',
+    INFEASIBLE: 'infeasible',
+    UNBOUNDED: 'unbounded',
+    TIME_LIMIT: 'timelimit',
+    UNKNOWN: 'unknown',
+    ERROR: 'error'
+  };
+  
+  function parseStatus(output) {
+    if (output.includes('optimal solution found')) return Status.OPTIMAL;
+    if (output.includes('problem is infeasible')) return Status.INFEASIBLE;
+    if (output.includes('problem is unbounded')) return Status.UNBOUNDED;
+    if (output.includes('time limit reached')) return Status.TIME_LIMIT;
+    return Status.UNKNOWN;
+  }
+  
+  function parseSolution(output, rawSolution) {
+    var variables = {};
+    var objective = { value: null };
+    
+    // Use rawSolution if available (more reliable)
+    var solText = rawSolution || output;
+    
+    var objMatch = solText.match(/objective value:\s*([\d.e+-]+)/i);
+    if (objMatch) {
+      objective.value = parseFloat(objMatch[1]);
+    }
+    
+    // Match ZIMPL-style variable names: x$sun#0, effSum$star#1, b_sun_10, etc.
+    // Format: variableName    value    (obj:coef)
+    var varRegex = /^([\w$#]+)\s+([\d.e+-]+)/gm;
+    var match;
+    
+    while ((match = varRegex.exec(solText)) !== null) {
+      var name = match[1];
+      var value = parseFloat(match[2]);
+      if (!isNaN(value) && name !== 'objective' && name !== 'solution') {
+        variables[name] = value;
+      }
+    }
+    
+    return { variables: variables, objective: objective };
+  }
+  
+  function parseStatistics(output) {
+    var stats = { solvingTime: null, nodes: null, iterations: null, gap: null };
+    
+    var timeMatch = output.match(/Solving Time \(sec\)\s*:\s*([\d.]+)/);
+    if (timeMatch) stats.solvingTime = parseFloat(timeMatch[1]);
+    
+    var nodesMatch = output.match(/Nodes\s*:\s*(\d+)/);
+    if (nodesMatch) stats.nodes = parseInt(nodesMatch[1]);
+    
+    var iterMatch = output.match(/LP Iterations\s*:\s*(\d+)/);
+    if (iterMatch) stats.iterations = parseInt(iterMatch[1]);
+    
+    var gapMatch = output.match(/Gap\s*:\s*([\d.]+)\s*%/);
+    if (gapMatch) stats.gap = parseFloat(gapMatch[1]);
+    
+    return stats;
+  }
+  
+  function init(options) {
+    options = options || {};
+    
+    if (isInitialized) {
+      return Promise.resolve();
+    }
+    if (initPromise) {
+      return initPromise;
+    }
+    
+    initPromise = new Promise(function(resolve, reject) {
+      try {
+        var wasmPath = options.wasmPath || (__SCIP_SCRIPT_DIR__ + 'scip.wasm');
+        
+        createSCIP({
+          locateFile: function(path) {
+            if (path.endsWith('.wasm')) {
+              return wasmPath;
+            }
+            return path;
+          },
+          print: function(text) {
+            if (scipModule && scipModule.onStdout) {
+              scipModule.onStdout(text);
+            }
+          },
+          printErr: function(text) {
+            if (scipModule && scipModule.onStderr) {
+              scipModule.onStderr(text);
+            }
+          }
+        }).then(function(module) {
+          scipModule = module;
+          
+          if (scipModule.FS) {
+            try { scipModule.FS.mkdir('/problems'); } catch (e) {}
+            try { scipModule.FS.mkdir('/solutions'); } catch (e) {}
+            try { scipModule.FS.mkdir('/settings'); } catch (e) {}
+          }
+          
+          isInitialized = true;
+          if (readyResolve) readyResolve();
+          resolve();
+        }).catch(function(err) {
+          var error = new Error('SCIP WASM loading failed: ' + (err.message || err));
+          if (readyReject) readyReject(error);
+          reject(error);
+        });
+      } catch (err) {
+        if (readyReject) readyReject(err);
+        reject(err);
+      }
+    });
+    
+    return initPromise;
+  }
+  
+  function solve(problem, options) {
+    options = options || {};
+    
+    var doSolve = function() {
+      var format = options.format || 'lp';
+      var timeLimit = options.timeLimit || 3600;
+      var gap = options.gap || null;
+      var verbose = options.verbose || false;
+      var parameters = options.parameters || {};
+      
+      var stdout = '';
+      var stderr = '';
+      
+      scipModule.onStdout = function(text) {
+        stdout += text + '\n';
+        if (verbose) console.log('[SCIP]', text);
+      };
+      
+      scipModule.onStderr = function(text) {
+        stderr += text + '\n';
+        if (verbose) console.error('[SCIP Error]', text);
+      };
+      
+      try {
+        var formatExtMap = { mps: 'mps', zpl: 'zpl', cip: 'cip', lp: 'lp' };
+        var ext = formatExtMap[format] || 'lp';
+        var problemFile = '/problems/problem.' + ext;
+        var solutionFile = '/solutions/solution.sol';
+        
+        scipModule.FS.writeFile(problemFile, problem);
+        
+        var commands = [];
+        commands.push('set limits time ' + timeLimit);
+        
+        if (gap !== null) {
+          commands.push('set limits gap ' + gap);
+        }
+        
+        for (var key in parameters) {
+          if (parameters.hasOwnProperty(key)) {
+            commands.push('set ' + key + ' ' + parameters[key]);
+          }
+        }
+        
+        commands.push('read ' + problemFile);
+        commands.push('optimize');
+        commands.push('display solution');
+        commands.push('write solution ' + solutionFile);
+        commands.push('display statistics');
+        commands.push('quit');
+        
+        var settingsContent = commands.join('\n');
+        scipModule.FS.writeFile('/settings/commands.txt', settingsContent);
+        
+        var exitCode = scipModule.callMain(['-b', '/settings/commands.txt']);
+        
+        // Read rawSolution first (more reliable for parsing)
+        var rawSolution = null;
+        try {
+          rawSolution = scipModule.FS.readFile(solutionFile, { encoding: 'utf8' });
+        } catch (e) {}
+        
+        var status = parseStatus(stdout);
+        var parsed = parseSolution(stdout, rawSolution);
+        var statistics = parseStatistics(stdout);
+        
+        // Cleanup
+        var cleanupFiles = [
+          '/problems/problem.lp', '/problems/problem.mps',
+          '/problems/problem.zpl', '/problems/problem.cip',
+          '/solutions/solution.sol', '/settings/commands.txt'
+        ];
+        for (var i = 0; i < cleanupFiles.length; i++) {
+          try { scipModule.FS.unlink(cleanupFiles[i]); } catch (e) {}
+        }
+        
+        return {
+          status: status,
+          objective: parsed.objective.value,
+          variables: parsed.variables,
+          statistics: statistics,
+          exitCode: exitCode,
+          output: verbose ? stdout : undefined,
+          rawSolution: rawSolution
+        };
+        
+      } catch (error) {
+        return {
+          status: Status.ERROR,
+          error: error.message,
+          output: stdout + stderr
+        };
+      }
+    };
+    
+    if (!isInitialized) {
+      return init(options).then(doSolve);
+    }
+    return Promise.resolve(doSolve());
+  }
+  
+  function minimize(problem, options) {
+    if (!problem.toLowerCase().includes('minimize')) {
+      problem = 'Minimize\n' + problem;
+    }
+    return solve(problem, options);
+  }
+  
+  function maximize(problem, options) {
+    if (!problem.toLowerCase().includes('maximize')) {
+      problem = 'Maximize\n' + problem;
+    }
+    return solve(problem, options);
+  }
+  
+  function version() {
+    var getVersion = function() {
+      var output = '';
+      scipModule.onStdout = function(text) { output += text + '\n'; };
+      scipModule.callMain(['--version']);
+      return output.trim();
+    };
+    
+    if (!isInitialized) {
+      return init().then(getVersion);
+    }
+    return Promise.resolve(getVersion());
+  }
+  
+  function isReady() {
+    return isInitialized;
+  }
+  
+  // Expose SCIP API
+  var SCIP = {
+    init: init,
+    ready: readyPromise,
+    isReady: isReady,
+    solve: solve,
+    minimize: minimize,
+    maximize: maximize,
+    version: version,
+    Status: Status
+  };
+  
+  global.SCIP = SCIP;
+  
+  // Auto-initialize
+  init().catch(function(err) {
+    console.error('[SCIP.js] Auto-initialization failed:', err.message);
+  });
+  
 })(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : globalThis);