@ohtaman/washi 0.4.0 → 0.6.0

package/dist/types/decomposition/benders.d.ts

@@ -0,0 +1,32 @@
+import type { BendersOptions, BendersResult } from "./types.js";
+/**
+ * Solve a problem using Benders Decomposition.
+ *
+ * Benders Decomposition partitions a problem into a Master Problem (containing complicating variables,
+ * such as discrete binary/integer design decisions, and an auxiliary objective estimator variable)
+ * and a Subproblem (typically a continuous LP or independent operational model).
+ *
+ * The master problem is solved iteratively, passing its tentative decision values to the subproblem callback.
+ * The subproblem callback evaluates feasibility and optimality, returning Benders Optimality Cuts or
+ * Feasibility Cuts to be dynamically added to the master until bounds converge.
+ *
+ * @param options Benders options including master model and subproblem callback
+ * @returns Result object containing status, objective, bounds, gap, iterations, and variable values
+ *
+ * @example
+ * ```ts
+ * const result = await master.solveBenders({
+ *   subproblem: () => {
+ *     const sub = new Model("OperationalSub");
+ *     const x = sub.continuous("x", { lb: 0 });
+ *     sub.objective(minimize(expr`2 * ${x}`));
+ *     sub.constraint(expr`${x} >= 30`, "demand");
+ *     sub.link(expr`${x} <= 50 * ${openVar}`);
+ *     return sub;
+ *   },
+ *   gapTolerance: 1e-4,
+ * });
+ * ```
+ */
+export declare function solveBenders(options: BendersOptions): Promise<BendersResult>;
+//# sourceMappingURL=benders.d.ts.map

package/dist/types/decomposition/benders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benders.d.ts","sourceRoot":"","sources":["../../../src/decomposition/benders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EACd,aAAa,EAEd,MAAM,YAAY,CAAC;AAiJpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC,CA8MxB"}

package/dist/types/decomposition/column-generation.d.ts

@@ -0,0 +1,34 @@
+import type { ColumnGenerationOptions, ColumnGenerationResult } from "./types.js";
+/**
+ * Solve a problem using Column Generation (Dantzig-Wolfe decomposition).
+ *
+ * Column Generation starts with a Restricted Master Problem (RMP) containing a small set of initial columns,
+ * repeatedly solves its continuous LP relaxation to obtain dual values (shadow prices), and calls a user-provided
+ * `pricing` subproblem callback to identify new columns with improving reduced costs.
+ * Once no improving columns exist, it optionally solves the master as a Mixed-Integer Program (MIP)
+ * to produce an integer solution.
+ *
+ * @param options Column generation options including master model and pricing callback
+ * @returns Result object containing status, objective, iterations, columns added, and final variable values
+ *
+ * @example
+ * ```ts
+ * const result = await master.solveColumnGeneration({
+ *   pricing: async () => {
+ *     const sub = new Model("Pricing");
+ *     const a = sub.integer("a", { lb: 0, ub: 2 });
+ *     sub.objective(maximize(expr`${(demandA.dual ?? 0)} * ${a}`));
+ *     sub.constraint(expr`45 * ${a} <= 100`);
+ *     await sub.solve();
+ *     return {
+ *       cost: 1,
+ *       type: "Integer",
+ *       coefficients: { demand_A: a.value ?? 0 },
+ *     };
+ *   },
+ *   finalizeAsMIP: true,
+ * });
+ * ```
+ */
+export declare function solveColumnGeneration<TColumnMeta = unknown>(options: ColumnGenerationOptions<TColumnMeta>): Promise<ColumnGenerationResult<TColumnMeta>>;
+//# sourceMappingURL=column-generation.d.ts.map

package/dist/types/decomposition/column-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-generation.d.ts","sourceRoot":"","sources":["../../../src/decomposition/column-generation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,sBAAsB,EAGvB,MAAM,YAAY,CAAC;AAKpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,qBAAqB,CAAC,WAAW,GAAG,OAAO,EAC/D,OAAO,EAAE,uBAAuB,CAAC,WAAW,CAAC,GAC5C,OAAO,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC,CA4K9C"}

package/dist/types/decomposition/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./column-generation.js";
+export * from "./benders.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/decomposition/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/decomposition/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC"}

package/dist/types/decomposition/types.d.ts

@@ -0,0 +1,230 @@
+import type { Model } from "../modeler/model.js";
+import type { Var } from "../modeler/variable.js";
+import type { Constraint } from "../modeler/constraint.js";
+import type { ParsedExpr } from "../modeler/parser.js";
+import type { SolverStatus, SolverSolution, SolverOptions, Solver, VarType } from "../modeler/index.js";
+/**
+ * Definition of a newly proposed column generated by a pricing subproblem.
+ */
+export interface ColumnProposal<TColumnMeta = unknown> {
+    /** Optional variable name for the column */
+    name?: string;
+    /** Variable domain type (defaults to "Continuous" during LP relaxation, cast to "Integer" during MIP finalization if requested) */
+    type?: VarType;
+    /** Variable lower bound (default: 0) */
+    lb?: number;
+    /** Variable upper bound (default: Infinity) */
+    ub?: number;
+    /** Objective cost coefficient */
+    cost: number;
+    /**
+     * Constraint coefficients for this column.
+     * Can be a record keyed by constraint name, Map of Constraint/name to coefficient,
+     * or an array of [constraint, coeff] tuples.
+     */
+    coefficients: Record<string, number> | Map<Constraint | string, number> | Array<[Constraint | string, number]> | Array<{
+        constraint: Constraint | string;
+        coeff: number;
+    }>;
+    /**
+     * Optional reduced cost computed by the subproblem.
+     * For minimization: negative values improve the master objective.
+     * For maximization: positive values improve the master objective.
+     */
+    reducedCost?: number;
+    /** Optional domain-specific metadata attached to this column (e.g. pattern vector) */
+    meta?: TColumnMeta;
+}
+/**
+ * Context provided to the pricing subproblem callback on each Column Generation iteration.
+ */
+export interface PricingContext<TColumnMeta = unknown> {
+    /** 1-based iteration index */
+    iteration: number;
+    /** Constraint shadow prices (duals) from the master LP relaxation, keyed by canonical constraint name */
+    duals: Record<string, number>;
+    /** Helper to retrieve the dual value (shadow price) of a specific constraint */
+    getDual: (constraintOrName: Constraint | string) => number;
+    /** Full solution payload of the restricted master LP relaxation */
+    masterSolution: SolverSolution;
+    /** Numerical tolerance for reduced cost optimality check */
+    reducedCostTolerance: number;
+    /** Master model instance */
+    master: Model;
+}
+/**
+ * Progress event emitted on each Column Generation iteration.
+ */
+export interface ColumnGenerationIterationInfo<TColumnMeta = unknown> {
+    iteration: number;
+    relaxationObjective: number | null;
+    columnsAdded: number;
+    proposedColumns: Array<ColumnProposal<TColumnMeta>>;
+}
+/**
+ * Options for `solveColumnGeneration`
+ */
+export interface ColumnGenerationOptions<TColumnMeta = unknown> {
+    /** Restricted Master Problem (RMP) model containing initial columns and constraints (optional when called via `master.solveColumnGeneration(...)`) */
+    master?: Model;
+    /**
+     * Pricing subproblem generator callback.
+     * Receives constraint duals (shadow prices) and returns one or more new columns with improving reduced costs,
+     * or `null` / `[]` when no improving columns exist (LP relaxation is optimal).
+     */
+    pricing: (context: PricingContext<TColumnMeta>) => Promise<ColumnProposal<TColumnMeta> | ColumnProposal<TColumnMeta>[] | null | undefined> | ColumnProposal<TColumnMeta> | ColumnProposal<TColumnMeta>[] | null | undefined;
+    /** Maximum number of column generation iterations (default: 100) */
+    maxIterations?: number;
+    /**
+     * Numerical tolerance to test if reduced cost improves the objective (default: 1e-6).
+     * For minimization, column is accepted if `reducedCost < -reducedCostTolerance`.
+     * For maximization, column is accepted if `reducedCost > reducedCostTolerance`.
+     */
+    reducedCostTolerance?: number;
+    /**
+     * Whether to solve the final Restricted Master Problem as a Mixed-Integer Program (MIP)
+     * after column generation terminates (default: true).
+     * When true, integer/binary columns generate an exact integer solution.
+     */
+    finalizeAsMIP?: boolean;
+    /** Solver name or instance to use for master problem (defaults to HiGHS) */
+    solver?: Solver | string;
+    /** Solver options passed to master solves */
+    solverOptions?: SolverOptions;
+    /** Optional callback invoked on each iteration */
+    onIteration?: (info: ColumnGenerationIterationInfo<TColumnMeta>) => void;
+}
+/**
+ * Result returned by `solveColumnGeneration`
+ */
+export interface ColumnGenerationResult<TColumnMeta = unknown> {
+    /** Final solver status ("Optimal", "Feasible", "Infeasible", etc.) */
+    status: SolverStatus;
+    /** Objective value of the final solution (MIP objective if finalized, otherwise LP relaxation objective) */
+    objectiveValue: number | null;
+    /** Optimal objective value of the continuous LP relaxation (theoretical dual bound) */
+    relaxationObjectiveValue: number | null;
+    /** Total number of column generation iterations performed */
+    iterations: number;
+    /** Total number of columns dynamically generated and injected into the master */
+    columnsAdded: number;
+    /** All dynamically generated columns and their associated `Var` handles */
+    generatedColumns: Array<{
+        variable: Var;
+        proposal: ColumnProposal<TColumnMeta>;
+    }>;
+    /** The master model containing all generated columns and the final solution state */
+    master: Model;
+    /** Primal variable values of the final solution */
+    values: Record<string, number>;
+}
+/**
+ * Definition of a Benders cut (optimality cut or feasibility cut) to be added to the master problem.
+ */
+export interface BendersCut {
+    /**
+     * Cut classification:
+     * - "optimality": Benders optimality cut bounding the master auxiliary objective variable theta
+     * - "feasibility": Benders feasibility cut cutting off an infeasible subproblem candidate
+     */
+    kind: "optimality" | "feasibility";
+    /** The linear constraint expression representing the cut */
+    constraint: Constraint | ParsedExpr;
+    /** Optional cut constraint name */
+    name?: string;
+    /** Optional subproblem objective or diagnostic value */
+    subproblemObjective?: number;
+    /** Optional dual values used to generate the cut */
+    dualValues?: Record<string, number>;
+}
+/**
+ * Context provided to the Benders subproblem callback on each iteration.
+ */
+export interface BendersSubproblemContext {
+    /** 1-based iteration index */
+    iteration: number;
+    /** Primal values of master decision variables from the current master solution */
+    masterValues: Record<string, number>;
+    /** Helper to look up the primal value of a master variable */
+    getMasterValue: (v: Var | string) => number;
+    /** Current master objective value */
+    masterObjective: number | null;
+    /** Current best lower bound */
+    lowerBound?: number;
+    /** Current best upper bound */
+    upperBound?: number;
+    /** Master model instance */
+    master: Model;
+}
+/**
+ * Progress event emitted on each Benders decomposition iteration.
+ */
+export interface BendersIterationInfo {
+    iteration: number;
+    masterObjective: number | null;
+    lowerBound?: number;
+    upperBound?: number;
+    cutsAdded: number;
+    proposedCuts: BendersCut[];
+}
+/**
+ * Result returned by a Benders subproblem callback.
+ * Can be:
+ * - A subproblem `Model` (with linking constraints registered via `sub.link(...)`) for automatic Benders cut generation,
+ * - Or `BendersCut | BendersCut[] | null | undefined` for manual cut definition.
+ */
+export type BendersSubproblemResult = Model | BendersCut | BendersCut[] | null | undefined;
+/**
+ * Options for `solveBenders`
+ */
+export interface BendersOptions {
+    /** Master problem model containing master variables (optional when called via `master.solveBenders(...)`) */
+    master?: Model;
+    /**
+     * Subproblem evaluation callback.
+     * Evaluates the subproblem given current master decisions.
+     * Can return a subproblem `Model` (with linking constraints registered via `sub.link(...)`) for automatic Benders cut generation,
+     * or manual `BendersCut | BendersCut[] | null | undefined`.
+     */
+    subproblem: (context: BendersSubproblemContext) => Promise<BendersSubproblemResult> | BendersSubproblemResult;
+    /**
+     * Optional reference to the auxiliary theta variable in the master model.
+     * If not provided, WaSHI automatically detects a variable named "theta" / "__benders_theta"
+     * or injects an auxiliary continuous theta variable into the master objective.
+     */
+    theta?: Var | string;
+    /** Maximum number of Benders iterations (default: 100) */
+    maxIterations?: number;
+    /** Relative optimality gap convergence tolerance `|upper - lower| / (|upper| + 1e-10)` (default: 1e-4) */
+    gapTolerance?: number;
+    /** Solver name or instance to use for master problem */
+    solver?: Solver | string;
+    /** Solver options passed to master solves */
+    solverOptions?: SolverOptions;
+    /** Optional callback invoked on each iteration */
+    onIteration?: (info: BendersIterationInfo) => void;
+}
+/**
+ * Result returned by `solveBenders`
+ */
+export interface BendersResult {
+    /** Final solver status ("Optimal", "Feasible", "Infeasible", etc.) */
+    status: SolverStatus;
+    /** Final objective value */
+    objectiveValue: number | null;
+    /** Best lower bound achieved */
+    lowerBound?: number;
+    /** Best upper bound achieved */
+    upperBound?: number;
+    /** Final relative optimality gap */
+    gap?: number;
+    /** Number of iterations performed */
+    iterations: number;
+    /** Number of Benders cuts added to the master problem */
+    cutsAdded: number;
+    /** Master model containing all generated cuts and final solution */
+    master: Model;
+    /** Final primal values of master decision variables */
+    values: Record<string, number>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/decomposition/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/decomposition/types.ts"],"names":[],"mappings":"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"}

package/dist/types/index.d.ts

@@ -4,8 +4,9 @@
  * Domain-pure algebraic modeling with WebAssembly (HiGHS, Z3, GLPK) and pluggable solvers.
  * Supports LP (Linear Programming), MIP (Mixed-Integer Programming), QP (Quadratic Programming), and SMT.
  */
-export { Model, type ModelOptions, type BoundsOptions, Var, type VarOptions, LinExpr, QuadExpr, type Expr, type QuadTerm, sum, dot, Constraint, BoolVar, BoolExpr, BoolOp, and, or, not, implies, xor, parseExpr, parseConstraint, expr, c, generateLpString, type LpModelData, type LpExportResult, } from "./modeler/index.js";
-export { normalizeSense, type VarType, type OptimizationSense, type ComparisonSense, type SolverStatus, type SolveOptions, type SolverSolution, } from "./modeler/types.js";
-export { type Solver, type SolverOptions, type SolverResult, type SolverCheckResult, type SolverCapabilities, HighsSolver, HiGHS, MockSolver, registerSolver, getSolver, setDefaultSolver, listAvailableSolvers, } from "./modeler/solvers/index.js";
-export { getHighs, solveLpWithHighs, setHighsWasmUrl, getHighsWasmUrl, OFFICIAL_HIGHS_CDN_WASM_URL, isValidWasmHeader, probeWasmUrl, resolveBrowserWasmUrl, } from "./modeler/solvers/highs/index.js";
+export { Model, type ModelOptions, type BoundsOptions, type BinaryOptions, type IndicatorOptions, type ConstraintItem, type KeyCollection, deriveBigMForLe, deriveBigMForGe, validateUserBigM, buildIndicatorLinearization, linearizeModelForMip, type LinearizationResult, validateModelIntegrity, maximize, minimize, type ObjectiveExpr, type ObjectiveSpec, Var, type VarOptions, LinExpr, QuadExpr, type Expr, type DotTerm, type DotVarContainer, type DotCoeffContainer, type QuadTerm, sum, dot, Constraint, BoolVar, BoolExpr, BoolOp, type LogicElement, type LogicInput, and, or, not, implies, xor, parseExpr, parseConstraint, expr, type ParsedExpr, type ExprResolver, generateLpString, buildLpSymbolMaps, isLpExportResult, sanitizeIdentifier, type LpModelData, type LpSymbolMaps, type LpExportResult, validateModelSolution, type SolutionValidationOptions, type ViolationType, type SolutionViolation, type SolutionValidationSummary, type SolutionValidationReport, } from "./modeler/index.js";
+export { normalizeSense, type VarType, type OptimizationSense, type ComparisonSense, type SolverStatus, type TerminationStatus, type SolveProgressEvent, type SolveOptions, type SolverSolution, type CheckResult, type ColumnDefinition, } from "./modeler/types.js";
+export { solveColumnGeneration, solveBenders, type ColumnProposal, type PricingContext, type ColumnGenerationIterationInfo, type ColumnGenerationOptions, type ColumnGenerationResult, type BendersCut, type BendersSubproblemContext, type BendersSubproblemResult, type BendersIterationInfo, type BendersOptions, type BendersResult, } from "./decomposition/index.js";
+export { type Solver, type SolverOptions, type SolverResult, type SolverCheckResult, type SolverCapabilities, type SolveModelData, type CheckModelData, type LogicalConstraintItem, HighsSolver, HiGHS, MockSolver, type MockSolverOptions, registerSolver, getSolver, setDefaultSolver, listAvailableSolvers, } from "./modeler/solvers/index.js";
+export { getHighs, solveLpWithHighs, setHighsWasmUrl, getHighsWasmUrl, Highs, type HighsSolutionResult, type HighsSolutionColumn, type HighsSolutionRow, } from "./modeler/solvers/highs/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,KAAK,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,GAAG,EACH,KAAK,UAAU,EACf,OAAO,EACP,QAAQ,EACR,KAAK,IAAI,EACT,KAAK,QAAQ,EACb,GAAG,EACH,GAAG,EACH,UAAU,EACV,OAAO,EACP,QAAQ,EACR,MAAM,EACN,GAAG,EACH,EAAE,EACF,GAAG,EACH,OAAO,EACP,GAAG,EACH,SAAS,EACT,eAAe,EACf,IAAI,EACJ,CAAC,EACD,gBAAgB,EAChB,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,cAAc,GACpB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EACL,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,WAAW,EACX,KAAK,EACL,UAAU,EACV,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,2BAA2B,EAC3B,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,GACtB,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,KAAK,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,2BAA2B,EAC3B,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,QAAQ,EACR,QAAQ,EACR,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,GAAG,EACH,KAAK,UAAU,EACf,OAAO,EACP,QAAQ,EACR,KAAK,IAAI,EACT,KAAK,OAAO,EACZ,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,GAAG,EACH,GAAG,EACH,UAAU,EACV,OAAO,EACP,QAAQ,EACR,MAAM,EACN,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,GAAG,EACH,EAAE,EACF,GAAG,EACH,OAAO,EACP,GAAG,EACH,SAAS,EACT,eAAe,EACf,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,qBAAqB,EACrB,KAAK,yBAAyB,EAC9B,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,GAC9B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,qBAAqB,EACrB,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,6BAA6B,EAClC,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EACL,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,WAAW,EACX,KAAK,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,KAAK,EACL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,kCAAkC,CAAC"}

package/dist/types/modeler/big-m.d.ts

@@ -0,0 +1,75 @@
+import { LinExpr } from "./expression.js";
+import { Var } from "./variable.js";
+/**
+ * Options for indicator constraints with Big-M linearization.
+ */
+export interface IndicatorOptions {
+    /**
+     * The binary variable value (0 or 1) that activates the constraint.
+     * Defaults to 1 (i.e. constraint holds when binVar == 1).
+     */
+    activeValue?: 0 | 1;
+    /**
+     * Explicit Big-M scalar value override.
+     * If omitted, WaSHI automatically derives a safe, tight Big-M from the
+     * linear expression terms and finite variable bounds.
+     * If provided, it must be a finite positive number.
+     *
+     * Note: The user is responsible for ensuring that a custom M is sufficiently
+     * large to avoid truncating valid solutions while small enough to maintain
+     * numerical stability.
+     */
+    M?: number;
+    /**
+     * Base name for generated linear constraints.
+     */
+    name?: string;
+}
+/**
+ * Validates a user-supplied Big-M override value.
+ * Must be a finite positive number (> 0).
+ */
+export declare function validateUserBigM(M: number, constraintName: string): void;
+/**
+ * Derives a sufficient, tight Big-M value for a "<=" linear inequality:
+ *   lhs <= rhs  (or terms <= effectiveRhs)
+ *
+ * When the indicator variable is inactive, the relaxed constraint becomes:
+ *   terms <= effectiveRhs + M
+ *
+ * For the constraint to be trivially satisfied over all domain values x in [lb, ub]:
+ *   effectiveRhs + M >= max(terms)  <=>  M >= max(terms) - effectiveRhs
+ *
+ * Therefore, the safe tight non-negative Big-M is:
+ *   M = max(0, max(terms) - effectiveRhs)
+ *
+ * Fails with an actionable error if any variable lacks a required finite bound
+ * or if finite arithmetic overflows.
+ */
+export declare function deriveBigMForLe(lhs: LinExpr, rhs: number, constraintName: string): number;
+/**
+ * Derives a sufficient, tight Big-M value for a ">=" linear inequality:
+ *   lhs >= rhs  (or terms >= effectiveRhs)
+ *
+ * When the indicator variable is inactive, the relaxed constraint becomes:
+ *   terms >= effectiveRhs - M
+ *
+ * For the constraint to be trivially satisfied over all domain values x in [lb, ub]:
+ *   effectiveRhs - M <= min(terms)  <=>  M >= effectiveRhs - min(terms)
+ *
+ * Therefore, the safe tight non-negative Big-M is:
+ *   M = max(0, effectiveRhs - min(terms))
+ *
+ * Fails with an actionable error if any variable lacks a required finite bound
+ * or if finite arithmetic overflows.
+ */
+export declare function deriveBigMForGe(lhs: LinExpr, rhs: number, constraintName: string): number;
+/**
+ * Constructs the linearized LHS and RHS for a single directional indicator constraint
+ * and verifies that all resulting coefficients and shifted RHS values remain finite.
+ */
+export declare function buildIndicatorLinearization(binVar: Var, lhs: LinExpr, sense: "<=" | ">=", rhs: number, activeVal: 0 | 1, M: number, constraintName: string): {
+    lhs: LinExpr;
+    rhs: number;
+};
+//# sourceMappingURL=big-m.d.ts.map

package/dist/types/modeler/big-m.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"big-m.d.ts","sourceRoot":"","sources":["../../../src/modeler/big-m.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEpB;;;;;;;;;OASG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAMxE;AA6CD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,MAAM,GACrB,MAAM,CAyDR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,MAAM,GACrB,MAAM,CAyDR;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,GAAG,EACX,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,IAAI,GAAG,IAAI,EAClB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,CAAC,GAAG,CAAC,EAChB,CAAC,EAAE,MAAM,EACT,cAAc,EAAE,MAAM,GACrB;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAsF/B"}

package/dist/types/modeler/boolean-expr.d.ts

@@ -1,18 +1,31 @@
-import type { Constraint } from "./constraint.js";
+import { Constraint } from "./constraint.js";
+import type { LinExpr } from "./expression.js";
+import type { QuadExpr } from "./quad-expr.js";
 export type LogicalOpType = "and" | "or" | "not" | "implies" | "xor" | "eq";
 export type LogicElement = BoolExpr | Constraint;
+export type LogicInput = LogicElement | LinExpr | QuadExpr;
 /**
- * Base abstract class for Boolean expressions in SMT / SAT
+ * Base abstract class for propositional / SMT Boolean expressions (`BoolVar` and `BoolOp`).
+ *
+ * **Solver capability note**: Registering `BoolExpr` constraints on a `Model` requires an
+ * SMT-capable solver such as Z3 (`{ solver: "z3" }`); LP/MIP solvers (HiGHS, GLPK) throw an Error.
  */
 export declare abstract class BoolExpr {
-    and(other: LogicElement): BoolOp;
-    or(other: LogicElement): BoolOp;
-    implies(consequent: LogicElement): BoolOp;
-    xor(other: LogicElement): BoolOp;
+    /** Logical conjunction (`this AND other`). Requires a `BoolVar`, `BoolExpr`, or comparison `Constraint`. */
+    and(other: LogicInput): BoolOp;
+    /** Logical disjunction (`this OR other`). Requires a `BoolVar`, `BoolExpr`, or comparison `Constraint`. */
+    or(other: LogicInput): BoolOp;
+    /** Logical implication (`this => consequent`). Requires a `BoolVar`, `BoolExpr`, or comparison `Constraint`. */
+    implies(consequent: LogicInput): BoolOp;
+    /** Logical exclusive-or (`this XOR other`). Requires a `BoolVar`, `BoolExpr`, or comparison `Constraint`. */
+    xor(other: LogicInput): BoolOp;
+    /** Logical negation (`NOT this`). */
     not(): BoolOp;
 }
 /**
- * Boolean variable (propositional variable in SAT / SMT)
+ * Propositional Boolean variable (`true` / `false`) for SAT / SMT modeling.
+ * Created via `m.bool(...)` and solved/checked with an SMT-capable solver (`{ solver: "z3" }`).
+ * For 0-1 arithmetic variables in LP/MIP, use `m.binary(...)` instead.
  */
 export declare class BoolVar extends BoolExpr {
     readonly id: number;
@@ -22,17 +35,93 @@ export declare class BoolVar extends BoolExpr {
     toString(): string;
 }
 /**
- * Compound Boolean operator AST node (And, Or, Not, Implies, Xor)
+ * Compound Boolean operator AST node (`and`, `or`, `not`, `implies`, `xor`).
  */
 export declare class BoolOp extends BoolExpr {
     readonly op: LogicalOpType;
     readonly children: LogicElement[];
-    constructor(op: LogicalOpType, children: LogicElement[]);
+    constructor(op: LogicalOpType, children: LogicInput[]);
     toString(): string;
 }
-export declare function and(...exprs: LogicElement[]): BoolOp;
-export declare function or(...exprs: LogicElement[]): BoolOp;
-export declare function not(expr: LogicElement): BoolOp;
-export declare function implies(antecedent: LogicElement, consequent: LogicElement): BoolOp;
-export declare function xor(...exprs: LogicElement[]): BoolOp;
+/**
+ * Logical conjunction (`e1 AND e2 AND ...`) over `BoolVar`, `BoolExpr`, or linear comparison `Constraint`s.
+ *
+ * **Solver capability note**: Logical constraints require an SMT-capable solver such as Z3
+ * (`new Model("...", { solver: "z3" })` after `import "@ohtaman/washi/solvers/z3"`).
+ * LP/MIP solvers (HiGHS, GLPK) throw an Error if logical constraints are present.
+ * Passing an unconstrained arithmetic expression (`LinExpr` / `QuadExpr`) throws an Error.
+ *
+ * @example
+ * ```ts
+ * const m = new Model("AndExample", { solver: "z3" });
+ * const a = m.bool("a");
+ * const x = m.integer("x", { lb: 0, ub: 20 });
+ * m.constraint(and(a, expr`${x} >= 10`), "both_active");
+ * ```
+ */
+export declare function and(...exprs: LogicInput[]): BoolOp;
+/**
+ * Logical disjunction (`e1 OR e2 OR ...`) over `BoolVar`, `BoolExpr`, or linear comparison `Constraint`s.
+ *
+ * **Solver capability note**: Logical constraints require an SMT-capable solver such as Z3
+ * (`new Model("...", { solver: "z3" })` after `import "@ohtaman/washi/solvers/z3"`).
+ * LP/MIP solvers (HiGHS, GLPK) throw an Error if logical constraints are present.
+ * Passing an unconstrained arithmetic expression (`LinExpr` / `QuadExpr`) throws an Error.
+ *
+ * @example
+ * ```ts
+ * const m = new Model("OrExample", { solver: "z3" });
+ * const x = m.integer("x", { lb: 0, ub: 20 });
+ * m.constraint(or(expr`${x} <= 5`, expr`${x} >= 15`), "disjoint_range");
+ * ```
+ */
+export declare function or(...exprs: LogicInput[]): BoolOp;
+/**
+ * Logical negation (`NOT e`) of a `BoolVar`, `BoolExpr`, or linear comparison `Constraint`.
+ *
+ * **Solver capability note**: Logical constraints require an SMT-capable solver such as Z3
+ * (`new Model("...", { solver: "z3" })` after `import "@ohtaman/washi/solvers/z3"`).
+ * LP/MIP solvers (HiGHS, GLPK) throw an Error if logical constraints are present.
+ *
+ * @example
+ * ```ts
+ * const m = new Model("NotExample", { solver: "z3" });
+ * const blocked = m.bool("blocked");
+ * m.constraint(not(blocked), "must_not_be_blocked");
+ * ```
+ */
+export declare function not(expr: LogicInput): BoolOp;
+/**
+ * Logical implication (`antecedent => consequent`) over `BoolVar`, `BoolExpr`, or linear comparison `Constraint`s.
+ *
+ * **Solver capability note**: Logical constraints require an SMT-capable solver such as Z3
+ * (`new Model("...", { solver: "z3" })` after `import "@ohtaman/washi/solvers/z3"`).
+ * LP/MIP solvers (HiGHS, GLPK) throw an Error if logical constraints are present
+ * (for LP/MIP 0-1 Big-M indicator constraints, use `m.indicator(binVar, constraint)` instead).
+ *
+ * @example
+ * ```ts
+ * const m = new Model("ImpliesExample", { solver: "z3" });
+ * const vip = m.bool("vip");
+ * const discount = m.integer("discount", { lb: 0, ub: 50 });
+ * m.constraint(implies(vip, expr`${discount} >= 20`), "vip_min_discount");
+ * ```
+ */
+export declare function implies(antecedent: LogicInput, consequent: LogicInput): BoolOp;
+/**
+ * Logical exclusive-or (`e1 XOR e2 ...`) over `BoolVar`, `BoolExpr`, or linear comparison `Constraint`s.
+ *
+ * **Solver capability note**: Logical constraints require an SMT-capable solver such as Z3
+ * (`new Model("...", { solver: "z3" })` after `import "@ohtaman/washi/solvers/z3"`).
+ * LP/MIP solvers (HiGHS, GLPK) throw an Error if logical constraints are present.
+ *
+ * @example
+ * ```ts
+ * const m = new Model("XorExample", { solver: "z3" });
+ * const shiftA = m.bool("shiftA");
+ * const shiftB = m.bool("shiftB");
+ * m.constraint(xor(shiftA, shiftB), "exactly_one_shift");
+ * ```
+ */
+export declare function xor(...exprs: LogicInput[]): BoolOp;
 //# sourceMappingURL=boolean-expr.d.ts.map

package/dist/types/modeler/boolean-expr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boolean-expr.d.ts","sourceRoot":"","sources":["../../../src/modeler/boolean-expr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIlD,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,IAAI,CAAC;AAE5E,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEjD;;GAEG;AACH,8BAAsB,QAAQ;IACrB,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAEtC;IAEM,EAAE,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAErC;IAEM,OAAO,CAAC,UAAU,EAAE,YAAY,GAAG,MAAM,CAE/C;IAEM,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAEtC;IAEM,GAAG,IAAI,MAAM,CAEnB;CACF;AAED;;GAEG;AACH,qBAAa,OAAQ,SAAQ,QAAQ;IACnC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,IAAI,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,GAAG,IAAI,CAAQ;IAEpC,YAAY,IAAI,CAAC,EAAE,MAAM,EAIxB;IAED,QAAQ,IAAI,MAAM,CAEjB;CACF;AAED;;GAEG;AACH,qBAAa,MAAO,SAAQ,QAAQ;IAClC,SAAgB,EAAE,EAAE,aAAa,CAAC;IAClC,SAAgB,QAAQ,EAAE,YAAY,EAAE,CAAC;IAEzC,YAAY,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,EAAE,EAItD;IAED,QAAQ,IAAI,MAAM,CAKjB;CACF;AAGD,wBAAgB,GAAG,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,MAAM,CAGpD;AAED,wBAAgB,EAAE,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,MAAM,CAGnD;AAED,wBAAgB,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAE9C;AAED,wBAAgB,OAAO,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,GAAG,MAAM,CAElF;AAED,wBAAgB,GAAG,CAAC,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,MAAM,CAGpD"}
+{"version":3,"file":"boolean-expr.d.ts","sourceRoot":"","sources":["../../../src/modeler/boolean-expr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,IAAI,CAAC;AAE5E,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEjD,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC;AAmC3D;;;;;GAKG;AACH,8BAAsB,QAAQ;IAC5B,4GAA4G;IACrG,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEpC;IAED,2GAA2G;IACpG,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEnC;IAED,gHAAgH;IACzG,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAE7C;IAED,6GAA6G;IACtG,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEpC;IAED,qCAAqC;IAC9B,GAAG,IAAI,MAAM,CAEnB;CACF;AAED;;;;GAIG;AACH,qBAAa,OAAQ,SAAQ,QAAQ;IACnC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,IAAI,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,GAAG,IAAI,CAAQ;IAEpC,YAAY,IAAI,CAAC,EAAE,MAAM,EAIxB;IAED,QAAQ,IAAI,MAAM,CAEjB;CACF;AAED;;GAEG;AACH,qBAAa,MAAO,SAAQ,QAAQ;IAClC,SAAgB,EAAE,EAAE,aAAa,CAAC;IAClC,SAAgB,QAAQ,EAAE,YAAY,EAAE,CAAC;IAEzC,YAAY,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,EAIpD;IAED,QAAQ,IAAI,MAAM,CAKjB;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,GAAG,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,CAGlD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,EAAE,CAAC,GAAG,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,CAGjD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAE5C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAE9E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,CAAC,GAAG,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,CAGlD"}