Quadratic In-Step Range

QuadraticInStepRangeFunction is a closed-interval gate, not a floor or step-rounding operation. For a quadratic polynomial $p(x)$, bounds $L\le U$, and exterior tolerance $\epsilon >0$:

$$g_{\epsilon }(p)=\{\begin{array}{ll}p(x),& L\le p(x)\le U,\\ 0,& p(x)\le L-\epsilon \text{or}p(x)\ge U+\epsilon ,\\ \text{undefined},& \text{otherwise}.\end{array}$$

The undefined bands make the continuous-domain boundary contract explicit: strict complements cannot be encoded exactly by finitely many non-strict inequalities. Both implementations create three mutually exclusive binary indicators $z_{in}$, $z_{low}$, and $z_{high}$ plus a signed result $y$. With a positive Big-M constant $M$, the solver model is:

$$\begin{array}{rl}p(x)-M{z}_{in}& \ge L-M,\\ p(x)+M{z}_{in}& \le U+M,\\ p(x)+M{z}_{low}& \le L-\epsilon +M,\\ p(x)-M{z}_{high}& \ge U+\epsilon -M,\\ z_{in}+z_{low}+z_{high}& =1,\\ y-p(x)-M{z}_{in}& \ge -M,\\ y-p(x)+M{z}_{in}& \le M,\\ y-M{z}_{in}& \le 0,\\ y+M{z}_{in}& \ge 0.\end{array}$$

The one-hot partition forces the inside branch throughout $[L,U]$, the low branch at or below $L-\epsilon$, and the high branch at or above $U+\epsilon$. The last four rows set $y=p(x)$ only on the inside branch and $y=0$ otherwise.

API

Kotlin

val p = QuadraticPolynomial(
    monomials = listOf(QuadraticMonomial.quadratic(Flt64.one, x, x)),
    constant = Flt64.zero
)
val f = QuadraticInStepRangeFunction(
    x = p,
    lower = Flt64.zero,
    upper = Flt64(4.0),
    bigM = Flt64(100.0),
    outsideTolerance = Flt64(1e-6),
    converter = IntoValue.Identity,
    name = "square_gate"
)

Rust

let p = Quadratic::new(
    vec![QuadraticMonomial::new_quadratic(1.0, x_index, x_index)],
    0.0,
);
let f = QuadraticInStepRangeFunction::with_parameters(
    11, "square_gate", p, 0.0, 4.0, 100.0, 1e-6,
);

The old Rust step-floor constructor and with_quadratic_bounds API were removed. A separate floor function should be used when the mathematical operation is $L+|s|\lfloor (U-L)/|s|\rfloor$.

Evaluation and registration

Evaluation returns the input on the closed interval, zero beyond the exterior tolerance, and null/None in either undefined tolerance band. Registration adds three binary indicators and the signed result helper, then emits nine rows. A linear input is emitted through the linear mechanism model; a quadratic input is emitted through the quadratic mechanism model.

Tests and source

• Kotlin source: QuadraticInStepRange.kt
• Rust source: quadratic_in_step_range.rs
• Kotlin independent tests: QuadraticInStepRangeFunctionDedicatedTest.kt and QuadraticFunctionGenericEvaluationTest.kt
• Rust independent test: function_symbol_quadratic_in_step_range.rs

Related pages

• Linear in-step range
• Quadratic masking range