Source: Core/LinearApproximation.js

  1. /*global define*/
  2. define([
  3.         './defined',
  4.         './DeveloperError'
  5.     ], function(
  6.         defined,
  7.         DeveloperError) {
  8.     'use strict';
  10.     /**
  11.      * An {@link InterpolationAlgorithm} for performing linear interpolation.
  12.      *
  13.      * @exports LinearApproximation
  14.      */
  15.     var LinearApproximation = {
  16.         type : 'Linear'
  17.     };
  19.     /**
  20.      * Given the desired degree, returns the number of data points required for interpolation.
  21.      * Since linear interpolation can only generate a first degree polynomial, this function
  22.      * always returns 2.
  23.      * @param {Number} degree The desired degree of interpolation.
  24.      * @returns {Number} This function always returns 2.
  25.      *
  26.      */
  27.     LinearApproximation.getRequiredDataPoints = function(degree) {
  28.         return 2;
  29.     };
  31.     /**
  32.      * Interpolates values using linear approximation.
  33.      *
  34.      * @param {Number} x The independent variable for which the dependent variables will be interpolated.
  35.      * @param {Number[]} xTable The array of independent variables to use to interpolate.  The values
  36.      * in this array must be in increasing order and the same value must not occur twice in the array.
  37.      * @param {Number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
  38.      * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
  39.      * @param {Number} yStride The number of dependent variable values in yTable corresponding to
  40.      * each independent variable value in xTable.
  41.      * @param {Number[]} [result] An existing array into which to store the result.
  42.      * @returns {Number[]} The array of interpolated values, or the result parameter if one was provided.
  43.      */
  44.     LinearApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride, result) {
  45.         //>>includeStart('debug', pragmas.debug);
  46.         if (xTable.length !== 2) {
  47.             throw new DeveloperError('The xTable provided to the linear interpolator must have exactly two elements.');
  48.         } else if (yStride <= 0) {
  49.             throw new DeveloperError('There must be at least 1 dependent variable for each independent variable.');
  50.         }
  51.         //>>includeEnd('debug');
  53.         if (!defined(result)) {
  54.             result = new Array(yStride);
  55.         }
  57.         var i;
  58.         var y0;
  59.         var y1;
  60.         var x0 = xTable[0];
  61.         var x1 = xTable[1];
  63.         //>>includeStart('debug', pragmas.debug);
  64.         if (x0 === x1) {
  65.             throw new DeveloperError('Divide by zero error: xTable[0] and xTable[1] are equal');
  66.         }
  67.         //>>includeEnd('debug');
  69.         for (i = 0; i < yStride; i++) {
  70.             y0 = yTable[i];
  71.             y1 = yTable[i + yStride];
  72.             result[i] = (((y1 - y0) * x) + (x1 * y0) - (x0 * y1)) / (x1 - x0);
  73.         }
  75.         return result;
  76.     };
  78.     return LinearApproximation;
  79. });