Sine

SinFunction is a sampled, piecewise-linear approximation of sine. It is a linear modeling primitive, not an exact trigonometric solver function.

WARNING

The default model is defined only by five samples on $[-\pi ,\pi ]$. Values outside the breakpoint domain evaluate to null, and values between samples follow straight-line interpolation.

Contract

• Input: x: LinearPolynomial<V>.
• Output: result, a linear polynomial supplied by the delegated univariate piecewise function.
• Samples: List<Point<Dim2, Flt64>> containing $(x,\sin x)$ points; the default list is generated by the implementation.
• Generic values use V : RealNumber<V>, V : NumberField<V> and an IntoValue<V> converter.
• Registration adds the ordinary univariate piecewise-linear helper variables and constraints.

Definition and mathematical model

For ordered sample points $(a_i,b_i)$, each segment is

$$s_i=\frac{b_{i+1}-b_i}{a_{i+1}-a_i},c_i=b_i-s_i{a}_i,y=s_{i}x+c_i(a_i\le x\le a_{i+1}).$$

The default samples are exactly:

$$(-\pi ,0),(-\frac{\pi }{2},-1),(0,0),(\frac{\pi }{2},1),(\pi ,0).$$

Thus the default is a five-point linear interpolation of sine, with no periodic extension and no exact $\sin (x)$ evaluation.

Solver mathematical model

Kotlin delegates to the binary-selector model. For every sampled segment $[t_i,t_{i+1}]$ with affine interpolation $f_i(x)=a_{i}x+b_i$, it registers

$$\sum _i{z}_i=1,$$$$t_i-M_i^L(1-z_i)\le x\le t_{i+1}+M_i^U(1-z_i),$$$$f_i(x)-M_i^{-}(1-z_i)\le y\le f_i(x)+M_i^{+}(1-z_i),z_i\in \{0,1\}.$$

Rust fixes 32 segments. With segment width $h$, selector $z_i\in \{0,1\}$, and gated offset $0\le {\delta }_i\le h{z}_i$, its equivalent registered form is

$$\sum _i{z}_i=1,x=\sum _i(t_i{z}_i+{\delta }_i),y=\sum _i(\sin t_i{z}_i+a_i{\delta }_i).$$

Neither solver receives an exact trigonometric constraint.

Current API

Kotlin

Source: Sin.kt (SinFunction)

The factory also accepts an explicit samplingPoints list. Points must be finite, have at least two entries, and have strictly increasing x-coordinates when the delegated piecewise implementation is registered or evaluated.

import fuookami.ospf.kotlin.core.solver.value.IntoValue
import fuookami.ospf.kotlin.core.symbol.function.SinFunction
import fuookami.ospf.kotlin.math.algebra.number.Flt64
import fuookami.ospf.kotlin.math.symbol.Symbol
import fuookami.ospf.kotlin.math.symbol.monomial.LinearMonomial
import fuookami.ospf.kotlin.math.symbol.polynomial.LinearPolynomial
import fuookami.ospf.kotlin.core.variable.RealVar

val x = RealVar("x")
val xPoly = LinearPolynomial(
    listOf(LinearMonomial(Flt64.one, x)), Flt64.zero
)
val sine = SinFunction(
    x = xPoly,
    converter = IntoValue.Identity,
    name = "sine"
)
val value = sine.evaluate(mapOf<Symbol, Flt64>(x to Flt64.zero))
check(value != null && value == Flt64.zero)

Rust

Rust exposes SinFunction:

SinFunction::new(
    id: u64,
    name: &str,
    input: Linear<V>,
) -> SinFunction<V>

The constructor fixes the modeling grid to 32 segments over [-π,π], creates a bounded continuous result_variable(), and registers piecewise-linear segment constraints. Rust's token evaluator computes sin(input) directly and has no Kotlin-style configurable samplingPoints argument; this means direct evaluation can differ from the piecewise model, especially outside the modeling grid.

Evaluate versus solver

evaluate follows the same delegated piecewise interpolation used by registration, but returns null for a missing input or an x-value outside the first and last breakpoints. Solver registration does not add an exact trigonometric relation; it registers the piecewise linear approximation and its Big-M/segment constraints.

Boundaries, tolerance, and Undefined

This function has no three-valued condition classifier and no tolerance parameter of its own. The numeric conversion and piecewise validation are the relevant boundaries. A malformed sample list (fewer than two points, non-finite values, duplicate or descending x-coordinates) fails the delegated piecewise validation. The endpoint convention is closed for the available segments.

Examples and tests

Kotlin

import fuookami.ospf.kotlin.core.solver.value.IntoValue
import fuookami.ospf.kotlin.core.symbol.function.SinFunction
import fuookami.ospf.kotlin.math.algebra.number.Flt64
import fuookami.ospf.kotlin.math.symbol.Symbol
import fuookami.ospf.kotlin.math.symbol.monomial.LinearMonomial
import fuookami.ospf.kotlin.math.symbol.polynomial.LinearPolynomial
import fuookami.ospf.kotlin.core.variable.RealVar

val x = RealVar("x")
val xPoly = LinearPolynomial(
    listOf(LinearMonomial(Flt64.one, x)), Flt64.zero
)
val sine = SinFunction(
    x = xPoly,
    converter = IntoValue.Identity,
    name = "sine"
)
val value = sine.evaluate(mapOf<Symbol, Flt64>(x to Flt64.zero))
check(value != null && value == Flt64.zero)

Rust

use ospf_rust_core::symbol::flatten::{Linear, LinearMonomial};
use ospf_rust_core::symbol::function::SinFunction;

let input = Linear::new(vec![LinearMonomial::new(1.0, 0)], 0.0);
let sine = SinFunction::new(1, "sin", input);
let _result = sine.result_variable();

• Core test: TrigonometricAndBivariateGenericEvaluateTest.kt
• Example directory (no dedicated sine file): linear_function

Rust source: sin.rs.

Related pages

• Cos
• Univariate Linear Piecewise
• Bivariate Linear Piecewise