@areb0s/scip.js 1.0.5

package/README.md

@@ -0,0 +1,276 @@
+# SCIP.js
+
+**SCIP Optimization Solver compiled to WebAssembly**
+
+Solve Linear Programming (LP), Mixed Integer Programming (MIP), and Mixed Integer Nonlinear Programming (MINLP) problems directly in the browser or Node.js.
+
+## Features
+
+- **LP**: Linear Programming
+- **MIP**: Mixed Integer Programming (binary, integer variables)
+- **MINLP**: Mixed Integer Nonlinear Programming
+- **Zero Dependencies**: Pure WebAssembly, no native bindings
+- **Browser & Node.js**: Works everywhere JavaScript runs
+- **Web Worker Support**: Non-blocking solver for long computations
+- **TypeScript**: Full type definitions included
+
+## Installation
+
+```bash
+npm install scip.js
+```
+
+Or use via CDN:
+
+```html
+<script type="module">
+  import SCIP from 'https://unpkg.com/scip.js/dist/index.mjs';
+</script>
+```
+
+## Quick Start
+
+```javascript
+import SCIP from 'scip.js';
+
+// Solve a linear programming problem
+const result = await SCIP.solve(`
+  Minimize
+    obj: 2 x + 3 y
+  Subject To
+    c1: x + y >= 4
+    c2: 2 x + y >= 5
+  Bounds
+    x >= 0
+    y >= 0
+  End
+`);
+
+console.log(result.status);     // 'optimal'
+console.log(result.objective);  // 7.0
+console.log(result.variables);  // { x: 1, y: 3 }
+```
+
+## API Reference
+
+### `SCIP.solve(problem, options?)`
+
+Solve an optimization problem.
+
+**Parameters:**
+- `problem` (string): Problem in LP format
+- `options` (object, optional):
+  - `format`: `'lp'` | `'mps'` | `'zpl'` (default: `'lp'`)
+  - `timeLimit`: Time limit in seconds (default: 3600)
+  - `gap`: Relative MIP gap tolerance (e.g., 0.01 for 1%)
+  - `verbose`: Enable verbose output (default: false)
+  - `parameters`: Additional SCIP parameters
+
+**Returns:** `Promise<Solution>`
+
+```typescript
+interface Solution {
+  status: 'optimal' | 'infeasible' | 'unbounded' | 'timelimit' | 'unknown' | 'error';
+  objective: number | null;
+  variables: Record<string, number>;
+  statistics: {
+    solvingTime: number | null;
+    nodes: number | null;
+    iterations: number | null;
+    gap: number | null;
+  };
+}
+```
+
+### `SCIP.minimize(problem, options?)`
+
+Convenience wrapper that ensures the problem is minimized.
+
+### `SCIP.maximize(problem, options?)`
+
+Convenience wrapper that ensures the problem is maximized.
+
+### `SCIP.init(options?)`
+
+Initialize the SCIP WASM module. Called automatically on first solve.
+
+### `SCIP.version()`
+
+Get SCIP version information.
+
+## LP Format Reference
+
+The LP format is a human-readable format for optimization problems:
+
+```
+\ Comments start with backslash
+Minimize (or Maximize)
+  obj: 2 x + 3 y - z
+
+Subject To
+  constraint1: x + y >= 10
+  constraint2: x - y <= 5
+  constraint3: x + 2 y + 3 z = 15
+
+Bounds
+  0 <= x <= 100
+  y >= 0
+  z free
+
+General (Integer variables)
+  x
+
+Binary (0-1 variables)
+  y
+
+End
+```
+
+## Examples
+
+### Linear Programming
+
+```javascript
+const result = await SCIP.minimize(`
+  obj: 100 x1 + 150 x2
+  Subject To
+    labor: 2 x1 + 3 x2 <= 120
+    materials: 4 x1 + 2 x2 <= 100
+  Bounds
+    x1 >= 0
+    x2 >= 0
+  End
+`);
+```
+
+### Mixed Integer Programming (Knapsack)
+
+```javascript
+const result = await SCIP.maximize(`
+  obj: 60 item1 + 100 item2 + 120 item3
+  Subject To
+    weight: 10 item1 + 20 item2 + 30 item3 <= 50
+  Binary
+    item1 item2 item3
+  End
+`);
+
+// result.variables = { item2: 1, item3: 1 }
+// result.objective = 220
+```
+
+### Transportation Problem
+
+```javascript
+const result = await SCIP.minimize(`
+  obj: 8 x11 + 6 x12 + 10 x13 + 9 x21 + 12 x22 + 7 x23
+  Subject To
+    supply1: x11 + x12 + x13 <= 100
+    supply2: x21 + x22 + x23 <= 150
+    demand1: x11 + x21 >= 80
+    demand2: x12 + x22 >= 70
+    demand3: x13 + x23 >= 60
+  Bounds
+    x11 >= 0
+    x12 >= 0
+    x13 >= 0
+    x21 >= 0
+    x22 >= 0
+    x23 >= 0
+  End
+`);
+```
+
+### With Time Limit and Gap
+
+```javascript
+const result = await SCIP.solve(problem, {
+  timeLimit: 60,  // 60 seconds
+  gap: 0.01,      // Stop when within 1% of optimal
+  verbose: true   // Print solver output
+});
+```
+
+## Web Worker Usage
+
+For long-running optimizations, use the Web Worker API to avoid blocking the main thread:
+
+```javascript
+import { createWorkerSolver } from 'scip.js';
+
+const solver = await createWorkerSolver();
+
+// Solve in background
+const result = await solver.solve(largeProblem, { timeLimit: 300 });
+
+// Clean up when done
+solver.terminate();
+```
+
+## Building from Source
+
+### Prerequisites
+
+- Docker
+- Bash
+
+### Build
+
+```bash
+# Clone repository
+git clone https://github.com/user/scip.js
+cd scip.js
+
+# Build WASM (uses Docker)
+./build.sh
+
+# Output in dist/
+ls dist/
+# scip.js  scip.wasm  index.mjs  types.d.ts
+```
+
+The build process:
+1. Downloads SCIP Optimization Suite
+2. Compiles with Emscripten to WebAssembly
+3. Bundles JavaScript wrapper
+
+## File Sizes
+
+| File | Size | Gzipped |
+|------|------|---------|
+| scip.wasm | ~5 MB | ~1.5 MB |
+| scip.js | ~50 KB | ~15 KB |
+
+## Limitations
+
+- **Single-threaded**: WASM runs single-threaded (use Web Workers for parallelism at application level)
+- **Memory**: Limited to ~2GB (WASM 32-bit limit)
+- **No callbacks**: Progress callbacks not yet supported
+- **ZIMPL disabled**: ZIMPL modeling language not included (use LP/MPS format)
+
+## Performance
+
+Typical solving times in browser (varies by problem complexity):
+
+| Problem Type | Variables | Constraints | Time |
+|--------------|-----------|-------------|------|
+| LP | 1,000 | 500 | <1s |
+| LP | 10,000 | 5,000 | ~5s |
+| MIP | 100 binary | 50 | ~1s |
+| MIP | 1,000 binary | 500 | ~30s |
+
+## License
+
+Apache 2.0 (same as SCIP)
+
+## Credits
+
+- [SCIP Optimization Suite](https://scipopt.org) - The underlying solver
+- [Emscripten](https://emscripten.org) - C++ to WebAssembly compiler
+- [poker-chipper](https://github.com/jstrieb/poker-chipper) - Reference SCIP WASM build
+
+## Links
+
+- [SCIP Documentation](https://scipopt.org/doc/html/)
+- [LP Format Reference](https://www.gurobi.com/documentation/current/refman/lp_format.html)
+- [MPS Format Reference](https://www.gurobi.com/documentation/current/refman/mps_format.html)

package/dist/basic.html

@@ -0,0 +1,445 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>SCIP.js - Optimization Solver Demo</title>
+  <style>
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+      min-height: 100vh;
+      color: #e0e0e0;
+      padding: 2rem;
+    }
+    .container {
+      max-width: 1000px;
+      margin: 0 auto;
+    }
+    h1 {
+      text-align: center;
+      margin-bottom: 0.5rem;
+      color: #4fc3f7;
+    }
+    .subtitle {
+      text-align: center;
+      color: #888;
+      margin-bottom: 2rem;
+    }
+    .card {
+      background: rgba(255, 255, 255, 0.05);
+      border: 1px solid rgba(255, 255, 255, 0.1);
+      border-radius: 12px;
+      padding: 1.5rem;
+      margin-bottom: 1.5rem;
+    }
+    .card h2 {
+      color: #4fc3f7;
+      margin-bottom: 1rem;
+      font-size: 1.2rem;
+    }
+    .examples {
+      display: flex;
+      gap: 0.5rem;
+      flex-wrap: wrap;
+      margin-bottom: 1rem;
+    }
+    .example-btn {
+      padding: 0.5rem 1rem;
+      background: rgba(79, 195, 247, 0.2);
+      border: 1px solid rgba(79, 195, 247, 0.3);
+      border-radius: 6px;
+      color: #4fc3f7;
+      cursor: pointer;
+      font-size: 0.9rem;
+      transition: all 0.2s;
+    }
+    .example-btn:hover {
+      background: rgba(79, 195, 247, 0.3);
+    }
+    textarea {
+      width: 100%;
+      height: 300px;
+      background: #0d1117;
+      border: 1px solid #30363d;
+      border-radius: 8px;
+      color: #c9d1d9;
+      font-family: 'Monaco', 'Menlo', monospace;
+      font-size: 13px;
+      padding: 1rem;
+      resize: vertical;
+    }
+    .options {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 1rem;
+      margin-bottom: 1rem;
+    }
+    .option {
+      display: flex;
+      flex-direction: column;
+      gap: 0.3rem;
+    }
+    .option label {
+      font-size: 0.85rem;
+      color: #888;
+    }
+    .option input, .option select {
+      padding: 0.5rem;
+      background: #0d1117;
+      border: 1px solid #30363d;
+      border-radius: 4px;
+      color: #c9d1d9;
+    }
+    .solve-btn {
+      width: 100%;
+      padding: 1rem;
+      background: linear-gradient(135deg, #4fc3f7, #29b6f6);
+      border: none;
+      border-radius: 8px;
+      color: #1a1a2e;
+      font-size: 1.1rem;
+      font-weight: 600;
+      cursor: pointer;
+      transition: transform 0.2s;
+    }
+    .solve-btn:hover:not(:disabled) {
+      transform: scale(1.02);
+    }
+    .solve-btn:disabled {
+      opacity: 0.6;
+      cursor: not-allowed;
+    }
+    .result {
+      background: #0d1117;
+      border-radius: 8px;
+      padding: 1rem;
+    }
+    .status {
+      display: inline-block;
+      padding: 0.3rem 0.8rem;
+      border-radius: 4px;
+      font-weight: 600;
+      margin-bottom: 1rem;
+    }
+    .status.optimal { background: #238636; color: white; }
+    .status.infeasible { background: #da3633; color: white; }
+    .status.unknown { background: #9e6a03; color: white; }
+    .status.error { background: #da3633; color: white; }
+    .result-grid {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 1rem;
+    }
+    .result-section h3 {
+      color: #4fc3f7;
+      margin-bottom: 0.5rem;
+      font-size: 1rem;
+    }
+    .result-section pre {
+      background: rgba(0,0,0,0.3);
+      padding: 0.8rem;
+      border-radius: 4px;
+      font-size: 0.9rem;
+      overflow-x: auto;
+    }
+    .loading {
+      display: none;
+      text-align: center;
+      padding: 2rem;
+    }
+    .loading.active {
+      display: block;
+    }
+    .spinner {
+      width: 40px;
+      height: 40px;
+      border: 3px solid rgba(79, 195, 247, 0.3);
+      border-top-color: #4fc3f7;
+      border-radius: 50%;
+      animation: spin 1s linear infinite;
+      margin: 0 auto 1rem;
+    }
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+    .footer {
+      text-align: center;
+      margin-top: 2rem;
+      color: #666;
+      font-size: 0.85rem;
+    }
+    .footer a {
+      color: #4fc3f7;
+      text-decoration: none;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>SCIP.js</h1>
+    <p class="subtitle">SCIP Optimization Solver in WebAssembly - LP, MIP, MINLP Support</p>
+    
+    <div class="card">
+      <h2>Problem Input (LP Format)</h2>
+      <div class="examples">
+        <button class="example-btn" onclick="loadExample('lp')">LP</button>
+        <button class="example-btn" onclick="loadExample('mip')">MIP</button>
+        <button class="example-btn" onclick="loadExample('minlp')">MINLP (Quadratic)</button>
+        <button class="example-btn" onclick="loadExample('minlp2')">MINLP (Facility)</button>
+        <button class="example-btn" onclick="loadExample('knapsack')">Knapsack</button>
+        <button class="example-btn" onclick="loadExample('transportation')">Transportation</button>
+      </div>
+      <textarea id="problem"></textarea>
+    </div>
+    
+    <div class="card">
+      <h2>Solver Options</h2>
+      <div class="options">
+        <div class="option">
+          <label>Time Limit (seconds)</label>
+          <input type="number" id="timeLimit" value="60" min="1" max="3600">
+        </div>
+        <div class="option">
+          <label>Gap Tolerance (%)</label>
+          <input type="number" id="gap" value="0" min="0" max="100" step="0.1">
+        </div>
+        <div class="option">
+          <label>Verbose Output</label>
+          <select id="verbose">
+            <option value="false">No</option>
+            <option value="true">Yes</option>
+          </select>
+        </div>
+      </div>
+      <button class="solve-btn" id="solveBtn" onclick="solveProblem()">
+        Solve Optimization Problem
+      </button>
+    </div>
+    
+    <div class="card">
+      <h2>Results</h2>
+      <div class="loading" id="loading">
+        <div class="spinner"></div>
+        <p>Solving... Please wait</p>
+      </div>
+      <div class="result" id="result">
+        <p style="color: #666;">Results will appear here after solving</p>
+      </div>
+    </div>
+    
+    <p class="footer">
+      Powered by <a href="https://scipopt.org" target="_blank">SCIP Optimization Suite</a> |
+      <a href="https://github.com/user/scip.js" target="_blank">GitHub</a>
+    </p>
+  </div>
+  
+  <script type="module">
+    import SCIP from './index.mjs';
+    
+    // Make available globally
+    window.SCIP = SCIP;
+    
+    // Example problems
+    const examples = {
+      lp: `\\ Simple Linear Programming Example
+\\ Minimize production cost
+Minimize
+  obj: 2 x1 + 3 x2 + 4 x3
+Subject To
+  demand1: x1 + x2 + x3 >= 100
+  demand2: 2 x1 + x2 >= 80
+  capacity: x1 + 2 x2 + 3 x3 <= 200
+Bounds
+  0 <= x1 <= 50
+  0 <= x2 <= 60
+  0 <= x3 <= 40
+End`,
+
+      mip: `\\ Mixed Integer Programming Example
+\\ Facility location problem
+Minimize
+  obj: 100 y1 + 150 y2 + 80 y3 + 5 x11 + 8 x12 + 6 x13 + 10 x21 + 4 x22 + 9 x23
+Subject To
+  \\ Customer demands
+  customer1: x11 + x21 >= 50
+  customer2: x12 + x22 >= 30
+  customer3: x13 + x23 >= 40
+  \\ Facility capacities (only if open)
+  facility1: x11 + x12 + x13 - 100 y1 <= 0
+  facility2: x21 + x22 + x23 - 100 y2 <= 0
+Bounds
+  0 <= x11
+  0 <= x12
+  0 <= x13
+  0 <= x21
+  0 <= x22
+  0 <= x23
+Binary
+  y1 y2 y3
+End`,
+
+      minlp: `\\ Mixed Integer Nonlinear Programming (MINLP) Example
+\\ Portfolio optimization with discrete lot sizes
+\\
+\\ Minimize quadratic risk (variance) with integer constraints
+\\ This is a MIQP (Mixed Integer Quadratic Program)
+Minimize
+  obj: [ x1^2 + 2 x2^2 + x1 * x2 ] / 2
+Subject To
+  \\ Total investment must be at least 100 units
+  budget: x1 + x2 >= 100
+  \\ Risk constraint
+  risk: x1 - x2 <= 50
+  \\ Minimum diversification
+  diverse: x2 >= 20
+Bounds
+  0 <= x1 <= 200
+  0 <= x2 <= 200
+General
+  x1
+End`,
+
+      minlp2: `\\ MINLP: Facility Location with Quadratic Costs
+\\ Open facilities (binary) with nonlinear shipping costs
+Minimize
+  obj: 50 open1 + 80 open2 + [ ship1^2 + ship2^2 ] / 2
+Subject To
+  \\ Must ship at least 10 units total
+  demand: ship1 + ship2 >= 10
+  \\ Can only ship from open facilities
+  cap1: ship1 - 20 open1 <= 0
+  cap2: ship2 - 20 open2 <= 0
+Bounds
+  0 <= ship1 <= 20
+  0 <= ship2 <= 20
+Binary
+  open1 open2
+End`,
+
+      knapsack: `\\ 0-1 Knapsack Problem
+\\ Select items to maximize value within weight limit
+Maximize
+  obj: 60 item1 + 100 item2 + 120 item3 + 80 item4 + 90 item5
+Subject To
+  weight: 10 item1 + 20 item2 + 30 item3 + 15 item4 + 25 item5 <= 50
+Binary
+  item1 item2 item3 item4 item5
+End`,
+
+      transportation: `\\ Transportation Problem
+\\ Ship goods from 2 plants to 3 customers at minimum cost
+Minimize
+  obj: 8 x11 + 6 x12 + 10 x13 + 9 x21 + 12 x22 + 7 x23
+Subject To
+  \\ Supply constraints
+  plant1: x11 + x12 + x13 <= 100
+  plant2: x21 + x22 + x23 <= 150
+  \\ Demand constraints
+  cust1: x11 + x21 >= 80
+  cust2: x12 + x22 >= 70
+  cust3: x13 + x23 >= 60
+Bounds
+  x11 >= 0
+  x12 >= 0
+  x13 >= 0
+  x21 >= 0
+  x22 >= 0
+  x23 >= 0
+End`
+    };
+    
+    window.loadExample = function(name) {
+      document.getElementById('problem').value = examples[name] || '';
+    };
+    
+    window.solveProblem = async function() {
+      const problem = document.getElementById('problem').value;
+      const timeLimit = parseInt(document.getElementById('timeLimit').value) || 60;
+      const gap = parseFloat(document.getElementById('gap').value) / 100 || null;
+      const verbose = document.getElementById('verbose').value === 'true';
+      
+      const loading = document.getElementById('loading');
+      const result = document.getElementById('result');
+      const solveBtn = document.getElementById('solveBtn');
+      
+      loading.classList.add('active');
+      result.innerHTML = '';
+      solveBtn.disabled = true;
+      
+      try {
+        const solution = await SCIP.solve(problem, {
+          timeLimit,
+          gap,
+          verbose
+        });
+        
+        displayResult(solution);
+      } catch (error) {
+        result.innerHTML = `
+          <span class="status error">Error</span>
+          <pre>${error.message}</pre>
+        `;
+      } finally {
+        loading.classList.remove('active');
+        solveBtn.disabled = false;
+      }
+    };
+    
+    function displayResult(solution) {
+      const result = document.getElementById('result');
+      
+      const statusClass = {
+        'optimal': 'optimal',
+        'infeasible': 'infeasible',
+        'unbounded': 'infeasible',
+        'timelimit': 'unknown',
+        'unknown': 'unknown',
+        'error': 'error'
+      }[solution.status] || 'unknown';
+      
+      let html = `<span class="status ${statusClass}">${solution.status.toUpperCase()}</span>`;
+      
+      if (solution.status === 'optimal' || solution.objective !== null) {
+        html += `
+          <div class="result-grid">
+            <div class="result-section">
+              <h3>Objective Value</h3>
+              <pre>${solution.objective}</pre>
+              
+              <h3>Variables</h3>
+              <pre>${JSON.stringify(solution.variables, null, 2)}</pre>
+            </div>
+            <div class="result-section">
+              <h3>Statistics</h3>
+              <pre>${JSON.stringify(solution.statistics, null, 2)}</pre>
+            </div>
+          </div>
+        `;
+      }
+      
+      if (solution.error) {
+        html += `<pre style="color: #da3633;">${solution.error}</pre>`;
+      }
+      
+      result.innerHTML = html;
+    }
+    
+    // Load LP example by default
+    loadExample('lp');
+    
+    // Initialize SCIP
+    console.log('Initializing SCIP.js...');
+    SCIP.init().then(() => {
+      console.log('SCIP.js ready!');
+    }).catch(err => {
+      console.error('Failed to initialize SCIP:', err);
+    });
+  </script>
+</body>
+</html>