[skip ci] allow cp314

Author: metab0t

.github/workflows/wheel.yml

@@ -30,7 +30,7 @@ jobs:
         env:
           # Select wheels
           CIBW_BUILD: "*-manylinux_x86_64 *-manylinux_aarch64 *-win_amd64 *-macosx_x86_64 *-macosx_arm64"
-          CIBW_SKIP: "cp38-* cp314*"
+          CIBW_SKIP: "cp38-* cp3??t-*"
           CIBW_ARCHS: "native"
           # use manylinux2014
           CIBW_MANYLINUX_X86_64_IMAGE: "quay.io/pypa/manylinux2014_x86_64"

GEMINI.md

@@ -0,0 +1,30 @@
+# PyOptInterface Modeling Guidelines
+
+When modeling with `pyoptinterface_native`, adhere to these patterns.
+
+## Solver Initialization
+- Use `pyoptinterface.<solver>.Model()`. Supported: `highs`, `gurobi`, `copt`, `ipopt`, `knitro`, `mosek`, `xpress`.
+- For Gurobi, you can manage environments with `poi.gurobi.Env()`.
+
+## Variables
+- `model.add_variable(lb=None, ub=None, domain=poi.VariableDomain.Continuous, name="", start=None)`
+- `model.add_m_variables(shape, ...)` returns a NumPy array of variables.
+
+## Constraints
+- Linear: `model.add_linear_constraint(expr, sense, rhs)` or `model.add_linear_constraint(lhs <= rhs)`.
+- Quadratic: `model.add_quadratic_constraint(expr, sense, rhs)`.
+- Matrix: `model.add_m_linear_constraints(A, x, sense, b)`.
+- Nonlinear: Wrap in `with nl.graph():` and use `model.add_nl_constraint(expr)`.
+
+## Objective
+- `model.set_objective(expr, sense)`.
+- Nonlinear: `with nl.graph(): model.add_nl_objective(expr, sense)`.
+
+## Attributes
+- Get: `model.get_model_attribute(poi.ModelAttribute.TerminationStatus)`.
+- Set: `model.set_variable_attribute(v, poi.VariableAttribute.LowerBound, 0.0)`.
+- Results: `model.get_variable_attribute(v, poi.VariableAttribute.Value)`.
+
+## Common Utilities
+- `poi.quicksum(terms)`: Efficiently sum variables/expressions.
+- `poi.Eq`, `poi.Leq`, `poi.Geq`: Aliases for constraint senses.

skills/pyoptinterface-expert/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: pyoptinterface-expert
+description: Specialized guidance for modeling mathematical optimization problems using the pyoptinterface_native library. Use when building optimization models (LP, QP, MIP, NLP), interfacing with solvers (Gurobi, HiGHS, Ipopt, etc.), and performing matrix-based or nonlinear modeling in Python.
+---
+
+# PyOptInterface Expert Skill
+
+This skill provides expert guidance for using `pyoptinterface` (POI), a high-performance Python modeling interface for mathematical optimization solvers.
+
+## Core Concepts
+
+POI follows a common modeling pattern:
+1. Create a solver-specific model (e.g., `poi.highs.Model()`).
+2. Add variables using `model.add_variable()` or `model.add_m_variables()`.
+3. Set the objective using `model.set_objective()`.
+4. Add constraints using `model.add_linear_constraint()`, `model.add_quadratic_constraint()`, or `model.add_nl_constraint()`.
+5. Call `model.optimize()` and retrieve results.
+
+## Key Workflows
+
+### 1. Basic Modeling
+```python
+import pyoptinterface as poi
+from pyoptinterface import highs
+
+model = highs.Model()
+x = model.add_variable(lb=0, name="x")
+y = model.add_variable(lb=0, name="y")
+
+model.set_objective(x + 2 * y, poi.ObjectiveSense.Minimize)
+model.add_linear_constraint(x + y >= 10, name="c1")
+
+model.optimize()
+status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)
+if status == poi.TerminationStatusCode.OPTIMAL:
+    print(f"x: {model.get_variable_attribute(x, poi.VariableAttribute.Value)}")
+```
+
+### 2. Matrix-based Modeling
+Use `add_m_variables` and `add_m_linear_constraints` for performance with NumPy/SciPy.
+```python
+import numpy as np
+x = model.add_m_variables((10,), lb=0)
+A = np.random.rand(5, 10)
+b = np.ones(5)
+model.add_m_linear_constraints(A, x, poi.Leq, b)
+```
+
+### 3. Nonlinear Modeling
+Nonlinear expressions must be wrapped in `nl.graph()` context.
+```python
+from pyoptinterface import nl
+with nl.graph():
+    model.add_nl_objective(x * x + nl.sin(y))
+    model.add_nl_constraint(x * y >= 5)
+```
+
+## Reference Documentation
+- API Reference: [references/api.md](references/api.md)
+- Modeling Examples: [references/examples.md](references/examples.md)
+
+## Best Practices
+- Use `poi.quicksum()` for large summations.
+- Check `TerminationStatus` before accessing variable values.
+- For large-scale models, prefer the Matrix API (`add_m_...`).

skills/pyoptinterface-expert/references/api.md

@@ -0,0 +1,65 @@
+# API Reference
+
+## Model Classes
+Imported from solver submodules:
+- `pyoptinterface.highs.Model`
+- `pyoptinterface.gurobi.Model`
+- `pyoptinterface.copt.Model`
+- `pyoptinterface.ipopt.Model`
+- `pyoptinterface.knitro.Model`
+- `pyoptinterface.mosek.Model`
+- `pyoptinterface.xpress.Model`
+
+## Core Methods
+### Model
+- `add_variable(lb, ub, domain, name, start)`: Add a single variable.
+- `add_m_variables(shape, lb, ub, domain, name, start)`: Add a NumPy array of variables.
+- `add_linear_constraint(expr, sense, rhs, name)`: Add a linear constraint.
+- `add_quadratic_constraint(expr, sense, rhs, name)`: Add a quadratic constraint.
+- `add_m_linear_constraints(A, x, sense, rhs)`: Add constraints in matrix form $Ax \sim b$.
+- `add_nl_constraint(expr)`: Add a nonlinear constraint (within `nl.graph()`).
+- `set_objective(expr, sense)`: Set objective function.
+- `set_nl_objective(expr, sense)`: Set nonlinear objective.
+- `optimize()`: Solve the model.
+- `get_model_attribute(attr)`: Get model information (Status, ObjVal, etc.).
+- `get_variable_attribute(v, attr)`: Get variable information (Value, ReducedCost, etc.).
+- `set_variable_attribute(v, attr, value)`: Set variable bounds, starts, etc.
+- `get_value(expr)`: Evaluate expression at the current solution.
+
+## Enums
+### `poi.VariableDomain`
+- `Continuous`
+- `Integer`
+- `Binary`
+
+### `poi.ConstraintSense`
+- `Equal` (or `poi.Eq`)
+- `LessEqual` (or `poi.Leq`)
+- `GreaterEqual` (or `poi.Geq`)
+
+### `poi.ObjectiveSense`
+- `Minimize`
+- `Maximize`
+- `Feasibility`
+
+### `poi.TerminationStatusCode`
+- `OPTIMAL`
+- `INFEASIBLE`
+- `UNBOUNDED`
+- `TIME_LIMIT`
+- `ITERATION_LIMIT`
+
+### `poi.ModelAttribute`
+- `TerminationStatus`
+- `ObjectiveValue`
+- `SolveTimeSec`
+- `RelativeGap`
+- `Silent`
+
+### `poi.VariableAttribute`
+- `Value`
+- `Name`
+- `LowerBound`
+- `UpperBound`
+- `Domain`
+- `PrimalStart`

skills/pyoptinterface-expert/references/examples.md

@@ -0,0 +1,61 @@
+# Modeling Examples
+
+## 1. Knapsack Problem (MIP)
+Maximize total value given a weight limit.
+```python
+import pyoptinterface as poi
+from pyoptinterface import highs
+
+values = [10, 15, 20, 8]
+weights = [2, 3, 5, 2]
+limit = 8
+
+model = highs.Model()
+x = model.add_m_variables(len(values), domain=poi.VariableDomain.Binary)
+
+model.set_objective(poi.quicksum(values[i] * x[i] for i in range(len(values))), poi.ObjectiveSense.Maximize)
+model.add_linear_constraint(poi.quicksum(weights[i] * x[i] for i in range(len(weights))) <= limit)
+
+model.optimize()
+if model.get_model_attribute(poi.ModelAttribute.TerminationStatus) == poi.TerminationStatusCode.OPTIMAL:
+    print("Selected items:", [i for i in range(len(values)) if model.get_variable_attribute(x[i], poi.VariableAttribute.Value) > 0.5])
+```
+
+## 2. Sparse Matrix Model (LP)
+Solve $Ax \le b$ using the matrix API.
+```python
+import numpy as np
+from scipy import sparse
+import pyoptinterface as poi
+from pyoptinterface import highs
+
+m, n = 100, 500
+A = sparse.random(m, n, density=0.1)
+b = np.random.rand(m)
+c = np.random.rand(n)
+
+model = highs.Model()
+x = model.add_m_variables(n, lb=0)
+
+model.set_objective(poi.quicksum(c[i] * x[i] for i in range(n)))
+model.add_m_linear_constraints(A, x, poi.Leq, b)
+
+model.optimize()
+```
+
+## 3. Nonlinear Rosenbrock Function (NLP)
+Minimize $f(x, y) = (1-x)^2 + 100(y-x^2)^2$.
+```python
+import pyoptinterface as poi
+from pyoptinterface import ipopt, nl
+
+model = ipopt.Model()
+x = model.add_variable(lb=-5, ub=5)
+y = model.add_variable(lb=-5, ub=5)
+
+with nl.graph():
+    model.add_nl_objective((1 - x)**2 + 100 * (y - x**2)**2, poi.ObjectiveSense.Minimize)
+
+model.optimize()
+print(f"Optimal x: {model.get_value(x)}, y: {model.get_value(y)}")
+```