Source: Core/LagrangePolynomialApproximation.js

  1. /*global define*/
  2. define([
  3.         './defined'
  4.     ], function(
  5.         defined) {
  6.     'use strict';
  8.     /**
  9.      * An {@link InterpolationAlgorithm} for performing Lagrange interpolation.
  10.      *
  11.      * @exports LagrangePolynomialApproximation
  12.      */
  13.     var LagrangePolynomialApproximation = {
  14.         type : 'Lagrange'
  15.     };
  17.     /**
  18.      * Given the desired degree, returns the number of data points required for interpolation.
  19.      *
  20.      * @param {Number} degree The desired degree of interpolation.
  21.      * @returns {Number} The number of required data points needed for the desired degree of interpolation.
  22.      */
  23.     LagrangePolynomialApproximation.getRequiredDataPoints = function(degree) {
  24.         return Math.max(degree + 1.0, 2);
  25.     };
  27.     /**
  28.      * Interpolates values using Lagrange Polynomial Approximation.
  29.      *
  30.      * @param {Number} x The independent variable for which the dependent variables will be interpolated.
  31.      * @param {Number[]} xTable The array of independent variables to use to interpolate.  The values
  32.      * in this array must be in increasing order and the same value must not occur twice in the array.
  33.      * @param {Number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
  34.      * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
  35.      * @param {Number} yStride The number of dependent variable values in yTable corresponding to
  36.      * each independent variable value in xTable.
  37.      * @param {Number[]} [result] An existing array into which to store the result.
  38.      * @returns {Number[]} The array of interpolated values, or the result parameter if one was provided.
  39.      */
  40.     LagrangePolynomialApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride, result) {
  41.         if (!defined(result)) {
  42.             result = new Array(yStride);
  43.         }
  45.         var i;
  46.         var j;
  47.         var length = xTable.length;
  49.         for (i = 0; i < yStride; i++) {
  50.             result[i] = 0;
  51.         }
  53.         for (i = 0; i < length; i++) {
  54.             var coefficient = 1;
  56.             for (j = 0; j < length; j++) {
  57.                 if (j !== i) {
  58.                     var diffX = xTable[i] - xTable[j];
  59.                     coefficient *= (x - xTable[j]) / diffX;
  60.                 }
  61.             }
  63.             for (j = 0; j < yStride; j++) {
  64.                 result[j] += coefficient * yTable[i * yStride + j];
  65.             }
  66.         }
  68.         return result;
  69.     };
  71.     return LagrangePolynomialApproximation;
  72. });