CircuitSpline.java

/*
 * Monotone interpolation ported from libresidfp's Spline.cpp.
 * Copyright 2007-2010 Antti Lankila
 * Copyright 2011-2015 Leandro Nini
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
package builder.resid.residfp.circuit;

/** Fritsch-Carlson interpolation keeps steep op-amp measurements monotone. */
final class CircuitSpline {
    private final double[][] coefficients;
    private int current;

    CircuitSpline(double[][] points) {
        int count = points.length - 1;
        double[] dx = new double[count], slope = new double[count], tangent = new double[count + 1];
        for (int i = 0; i < count; i++) {
            dx[i] = points[i + 1][0] - points[i][0];
            slope[i] = (points[i + 1][1] - points[i][1]) / dx[i];
        }
        tangent[0] = slope[0];
        tangent[count] = slope[count - 1];
        for (int i = 1; i < count; i++) {
            if (slope[i - 1] * slope[i] > 0) {
                double sum = dx[i - 1] + dx[i];
                tangent[i] = 3 * sum / ((sum + dx[i]) / slope[i - 1] + (sum + dx[i - 1]) / slope[i]);
            }
        }
        coefficients = new double[count][];
        for (int i = 0; i < count; i++) {
            double common = tangent[i] + tangent[i + 1] - 2 * slope[i];
            coefficients[i] = new double[]{points[i][0], points[i + 1][0],
                    common / dx[i] / dx[i], (slope[i] - tangent[i] - common) / dx[i],
                    tangent[i], points[i][1]};
        }
    }

    private double[] segment(double x) {
        if (x < coefficients[current][0] || x > coefficients[current][1]) {
            current = 0;
            while (current < coefficients.length - 1 && x > coefficients[current][1]) current++;
        }
        return coefficients[current];
    }

    double value(double x) {
        double[] c = segment(x);
        double diff = x - c[0];
        return ((c[2] * diff + c[3]) * diff + c[4]) * diff + c[5];
    }

    double derivative(double x) {
        double[] c = segment(x);
        double diff = x - c[0];
        return (3 * c[2] * diff + 2 * c[3]) * diff + c[4];
    }
}