Clamped linear interpolation
KnotVista gives interpolation code a focused review setting inside a Windows AI workspace. Use a compatible model to discuss the knots and endpoint policy, then check its edits against the accepted numeric range.
from math import isfinite
def interpolate(points, query):
def valid(x):
return type(x) in (int, float) and abs(x) <= 10**12 and isfinite(x)
if type(points) is not list or len(points) < 2 or not valid(query):
raise ValueError("knots.input")
if any(type(p) not in (list, tuple) or len(p) != 2 or
not all(valid(v) for v in p) for p in points):
raise ValueError("knots.point")
if any(a[0] >= b[0] for a,b in zip(points, points[1:])):
raise ValueError("knots.order")
if query <= points[0][0]:
return points[0][1]
for (x0,y0),(x1,y1) in zip(points, points[1:]):
if query <= x1:
t = (query-x0)/(x1-x0)
return (1-t)*y0+t*y1
return points[-1][1]| Project | Check exact knots and reject repeated coordinates, non-finite values or magnitudes above one trillion before computing a linear blend. |
|---|---|
| Review before applying | Compare actual behavior with the expected result. If a check fails, investigate it before applying more changes. |
| Connection | Base URL, credentials and a reachable server. |
from math import isfinite
def interpolate(points, query):
def valid(x):
return type(x) in (int, float) and abs(x) <= 10**12 and isfinite(x)
if type(points) is not list or len(points) < 2 or not valid(query):
raise ValueError("knots.input")
if any(type(p) not in (list, tuple) or len(p) != 2 or
not all(valid(v) for v in p) for p in points):
raise ValueError("knots.point")
if any(a[0] >= b[0] for a,b in zip(points, points[1:])):
raise ValueError("knots.order")
if query <= points[0][0]:
return points[0][1]
for (x0,y0),(x1,y1) in zip(points, points[1:]):
if query <= x1:
t = (query-x0)/(x1-x0)
return (1-t)*y0+t*y1
return points[-1][1]Keep numerical behavior consistent with its callers
KnotVista gives numerical maintenance a Windows coding workspace with a model-backed conversation about your files. Start with what a consumer expects from the calculation, including its input domain and boundary behavior. That establishes a useful review target before asking the assistant to simplify an implementation or alter how it handles unusual data.
The piecewise interpolation example offers a concrete project task. You might ask the model to examine ordered sample points and the handling of queries beyond their endpoints. Include the code that prepares those points and consumes the result so the discussion can distinguish a deliberate boundary policy from an accidental consequence of the loop.
Review a suggested change against exact knots, between-knot queries and values outside the supported span. Also inspect how invalid ordering reaches the caller. Run the project's numerical fixtures yourself and compare them with the agreed behavior; a smooth-looking visualization alone cannot show whether the boundary policy or rejected-input handling has changed.
An unrestricted AI model can be used when available through a supported OpenAI-compatible or Anthropic endpoint. Supply credentials as required and verify tools and context capacity for that connection. The model and provider still determine response restrictions; the application's mathematical contract comes from your requirements and the code you accept.
Useful questions for numerical maintenance
- What should I specify for a query outside the sample range?
State the intended endpoint policy explicitly, such as retaining the nearest endpoint value if that is your requirement. Include expected results on both sides of the range so the assistant does not substitute a different extrapolation policy.
- Why include the code that prepares sample points?
It determines ordering, duplicate positions and accepted numeric values before interpolation begins. A local change can appear correct while conflicting with those assumptions. Ask the model to inspect the preparation path before moving validation or sorting.
- Can I approve a change by checking only a chart?
A chart is useful for visible behavior, but subtle boundary changes can look similar. Compare explicit numeric fixtures at knots, between them and outside the span. Check how errors are reported as well as successful results.
- How should a rejected data set reach the interface?
Define whether the caller should display an error, omit the result or follow another existing rule. Review that path alongside the calculation. Avoid silently substituting a plausible value unless your application's contract deliberately calls for it.
KnotVista · Updated 2026-10-25