Stores current angles and interpolates with new angles
Check out {@link http://bl.ocks.org/mbostock/1346410| this example}

@param  {Object}     a   New data for slice
@return {Function}       Tweening function for the donut shape
@private
330837
function tweenArc(a) {
            let i = d3Interpolate.interpolate(this._current, a);

            this._current = i(0);

            return function(t) {
                return shape(i(t));
            };
        }
1361765
function (inData, outData, width, height, options) {
        options = defaultOptions(options, {amount: 1, angle: 0});
        var i, n = width * height * 4,
            amount = options.amount,
            angle = options.angle,
            x = Math.cos(-angle) * amount,
            y = Math.sin(-angle) * amount,

            a00 = -x - y,
            a10 = -x,
            a20 = y - x,
            a01 = -y,
            a21 = y,
            a02 = -y + x,
            a12 = x,
            a22 = y + x,

            tmpData = [];

        convolve3x3(inData, tmpData, width, height,
            [
                [a00, a01, a02],
                [a10, 0, a12],
                [a20, a21, a22]
            ]);

        for (i = 0; i < n; i += 4) {
            outData[i] = 128 + tmpData[i];
            outData[i + 1] = 128 + tmpData[i + 1];
            outData[i + 2] = 128 + tmpData[i + 2];
            outData[i + 3] = inData[i + 3];
        }
    }
978110
function (oldData) {
       var data = this.data;

       this.material.color.setStyle(data.color);
       this.material.opacity = data.opacity;
       this.material.transparent = data.transparent;
       this.material.wireframe = data.debug;
       this.material.side = parseSide(data.side);

       var diff = AFRAME.utils.diff(data, oldData);
       if ('src' in diff) {
         this.updateMap();
       }
       else if ('width' in diff || 'height' in diff || 'padding' in diff || 'left' in diff || 'top' in diff || 'bottom' in diff || 'right' in diff) {
         this.regenerateMesh();
       }
     }
1163811
function(a) {
          var i = d3.interpolate(this._current, a);
          this._current = i(0);
          return function(t) {
            return arc(i(t));
          };
        }
279508
function(newData) {
          // we use a one-directional loop to avoid feedback with 3-way bindings
          // since set() is applied locally anyway, this is still performant
          var def = $wilddogUtils.defer();
          this.$ref().set($wilddogUtils.toJSON(newData), $wilddogUtils.makeNodeResolver(def));
          return def.promise;
        }
420760
function(data){
  this.head;
  this.size;
  if(typeof data !== 'undefined'){
    this.head = new Node(data);
    this.size = 1;
  }else{
    this.head = null;
    this.size = 0;
  }
}
103061
function drawDataReferencePoints() {
            // Creates Dots on Data points
            var points = svg.select('.chart-group').selectAll('.dots')
                .data(layers)
                .enter()
                  .append('g')
                    .attr('class', 'dots')
                    .attr('d', ({values}) => area(values))
                    .attr('clip-path', 'url(#clip)');

            // Processes the points
            // TODO: Optimize this code
            points.selectAll('.dot')
                .data(({values}, index) => values.map((point) => ({index, point})))
                .enter()
                  .append('circle')
                    .attr('class','dot')
                    .attr('r', () => pointsSize)
                    .attr('fill', () => pointsColor)
                    .attr('stroke-width', '0')
                    .attr('stroke', pointsBorderColor)
                    .attr('transform', function(d) {
                        let {point} = d;
                        let key = xScale(point.date);

                        dataPoints[key] = dataPoints[key] || [];
                        dataPoints[key].push(d);

                        let {date, y, y0} = point;

                        return `translate( ${xScale(date)}, ${yScale(y + y0)} )`;
                    });
        }
539548
function ( angle ) {
            var rad = this.DEG_TO_RAD * angle,
                cosVal = Math.cos( rad ),
                sinVal = Math.sin( rad ),
                mtx = new $B.geom.Matrix( cosVal, sinVal, -sinVal, cosVal, 0, 0 );
            return this.concat( mtx );
        }
381348
function(data) {
    if (!data) return null;
    var geoset = [];
    var self = this;

    function applyNoise(geo, noise) {
      var n = new THREE.Vector3();
      for (var i = 0, numVerts = geo.vertices.length; i < numVerts; i++) {
        n.x = (self.random(i) - 0.5) * noise;
        n.y = (self.random(i + numVerts) - 0.5) * noise;
        n.z = (self.random(i + numVerts * 2) - 0.5) * noise;
        geo.vertices[i].add(n);
      }
    }

    var i, geo, verts;

    for (var j = 0; j < data.length; j++) {

      if (data[j].type == 'lathe') {
        var maxy = -99999;
        var points = [];
        verts = data[j].vertices;
        for (i = 0; i < verts.length; i += 2) {
          points.push(new THREE.Vector2(verts[i], verts[i + 1]));
          if (verts[i + 1] > maxy) {
            maxy = verts[i + 1];
          }
        }
        geo = new THREE.LatheGeometry(points, data[j]['segments'] || 8);
        geo.applyMatrix(new THREE.Matrix4().makeRotationFromEuler(new THREE.Euler(-Math.PI, 0, 0)));
        geo.applyMatrix(new THREE.Matrix4().makeTranslation(0, maxy, 0));
        if (data[j]['noise']) applyNoise(geo, data[j].noise);
        geoset.push(geo);
      }

      else if (data[j].type == 'extrude') {
        var shape = new THREE.Shape();
        verts = data[j].vertices;
        for (i = 0; i < verts.length; i+= 2) {
          if (i == 0) shape.moveTo(verts[i], verts[i + 1]);
          else shape.lineTo(verts[i], verts[i + 1]);
        }
        geo = new THREE.ExtrudeGeometry(shape, {amount: 1, bevelEnabled: false});
        geo.applyMatrix(new THREE.Matrix4().makeRotationFromEuler(new THREE.Euler(-Math.PI / 2, 0, 0)));
        if (data[j]['noise']) applyNoise(geo, data[j].noise);
        geoset.push(geo);
      }

      else if (data[j].type == 'mesh') {
        geo = new THREE.Geometry();
        verts = data[j].vertices;
        var faces = data[j].faces;
        for (var v = 0; v < verts.length; v += 3) {
          geo.vertices.push(new THREE.Vector3(verts[v], verts[v + 1], verts[v + 2]));
        }
        for (var f = 0; f < faces.length; f += 3) {
          geo.faces.push(new THREE.Face3(faces[f], faces[f + 1], faces[f + 2]));
        }
        if (this.data.flatShading || data[j]['flatShading']) {
          geo.computeFaceNormals();
        }
        else {
          geo.computeVertexNormals();
        }

        if (data[j]['mirror']) {
          geo.merge(geo, new THREE.Matrix4().makeRotationFromEuler(new THREE.Euler(0, Math.PI, 0)));
        }

        if (data[j]['noise']) applyNoise(geo, data[j].noise);
        geoset.push(geo);
      }
    }
    return geoset;
  }
1080425
function(data) {
    const seq = data.model.get("seq");
    const selection = this._getSelection(data.model);
    // get the status of the upper and lower row
    const getNextPrev= this._getPrevNextSelection(data.model);
    const mPrevSel = getNextPrev[0];
    const mNextSel = getNextPrev[1];

    const boxWidth = this.g.zoomer.get("columnWidth");
    const boxHeight = this.g.zoomer.get("rowHeight");

    // avoid unnecessary loops
    if (selection.length === 0) { return; }

    let hiddenOffset = 0;
    return (() => {
      const result = [];
      const end = seq.length - 1;
      for (let n = 0; n <= end; n++) {
        result.push((() => {
          if (data.hidden.indexOf(n) >= 0) {
            return hiddenOffset++;
          } else {
            const k = n - hiddenOffset;
            // only if its a new selection
            if (selection.indexOf(n) >= 0 && (k === 0 || selection.indexOf(n - 1) < 0 )) {
              return this._renderSelection({n:n,
                                           k:k,
                                           selection: selection,
                                           mPrevSel: mPrevSel,
                                           mNextSel:mNextSel,
                                           xZero: data.xZero,
                                           yZero: data.yZero,
                                           model: data.model});
            }
          }
        })());
      }
      return result;
    })();
  }
506831
function addMorphTargets( geometry, targets, parser ) {

  let hasMorphPosition = false;
  let hasMorphNormal = false;

  for ( var i = 0, il = targets.length; i < il; i++ ) {

    var target = targets[ i ];

    if ( target.POSITION !== undefined ) hasMorphPosition = true;
    if ( target.NORMAL !== undefined ) hasMorphNormal = true;

    if ( hasMorphPosition && hasMorphNormal ) break;

  }

  if ( !hasMorphPosition && !hasMorphNormal ) return Promise.resolve( geometry );

  const pendingPositionAccessors = [];
  const pendingNormalAccessors = [];

  for ( var i = 0, il = targets.length; i < il; i++ ) {

    var target = targets[ i ];

    if ( hasMorphPosition ) {

      // TODO: Error-prone use of a callback inside a loop.
      var accessor = target.POSITION !== undefined
        ? parser.getDependency( 'accessor', target.POSITION )
          .then( ( accessor ) => {
            // Cloning not to pollute original accessor below
            return cloneBufferAttribute( accessor );
          } )
        : geometry.attributes.position;

      pendingPositionAccessors.push( accessor );

    }

    if ( hasMorphNormal ) {

      // TODO: Error-prone use of a callback inside a loop.
      var accessor = target.NORMAL !== undefined
        ? parser.getDependency( 'accessor', target.NORMAL )
          .then( ( accessor ) => {
            return cloneBufferAttribute( accessor );
          } )
        : geometry.attributes.normal;

      pendingNormalAccessors.push( accessor );

    }

  }

  return Promise.all( [
    Promise.all( pendingPositionAccessors ),
    Promise.all( pendingNormalAccessors ),
  ] ).then( ( accessors ) => {

    const morphPositions = accessors[ 0 ];
    const morphNormals = accessors[ 1 ];

    for ( let i = 0, il = targets.length; i < il; i++ ) {

      const target = targets[ i ];
      const attributeName = 'morphTarget' + i;

      if ( hasMorphPosition ) {

        // Three.js morph position is absolute value. The formula is
        //   basePosition
        //     + weight0 * ( morphPosition0 - basePosition )
        //     + weight1 * ( morphPosition1 - basePosition )
        //     ...
        // while the glTF one is relative
        //   basePosition
        //     + weight0 * glTFmorphPosition0
        //     + weight1 * glTFmorphPosition1
        //     ...
        // then we need to convert from relative to absolute here.

        if ( target.POSITION !== undefined ) {

          const positionAttribute = morphPositions[ i ];
          positionAttribute.name = attributeName;

          const position = geometry.attributes.position;

          for ( var j = 0, jl = positionAttribute.count; j < jl; j++ ) {

            positionAttribute.setXYZ(
              j,
              positionAttribute.getX( j ) + position.getX( j ),
              positionAttribute.getY( j ) + position.getY( j ),
              positionAttribute.getZ( j ) + position.getZ( j ),
            );

          }

        }

      }

      if ( hasMorphNormal ) {

        // see target.POSITION's comment

        if ( target.NORMAL !== undefined ) {

          const normalAttribute = morphNormals[ i ];
          normalAttribute.name = attributeName;

          const normal = geometry.attributes.normal;

          for ( var j = 0, jl = normalAttribute.count; j < jl; j++ ) {

            normalAttribute.setXYZ(
              j,
              normalAttribute.getX( j ) + normal.getX( j ),
              normalAttribute.getY( j ) + normal.getY( j ),
              normalAttribute.getZ( j ) + normal.getZ( j ),
            );

          }

        }

      }

    }

    if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
    if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;

    return geometry;

  } );

}
134164
function(data){
  this.head;
  this.tail;
  this.size;
  if(typeof data !== 'undefined'){
    this.head = new Node(data);
    this.tail = this.head;
    this.size = 1;
  }else{
    this.head = null;
    this.tail = null;
    this.size = 0;
  }
}
108357
function(data){

			//Declare segments as a static property to prevent inheriting across the Chart type prototype
			this.segments = [];
			this.outerRadius = (helpers.min([this.chart.width,this.chart.height]) -	this.options.segmentStrokeWidth/2)/2;

			this.SegmentArc = Chart.Arc.extend({
				ctx : this.chart.ctx,
				x : this.chart.width/2,
				y : this.chart.height/2
			});

			//Set up tooltip events on the chart
			if (this.options.showTooltips){
				helpers.bindEvents(this, this.options.tooltipEvents, function(evt){
					var activeSegments = (evt.type !== 'mouseout') ? this.getSegmentsAtEvent(evt) : [];

					helpers.each(this.segments,function(segment){
						segment.restore(["fillColor"]);
					});
					helpers.each(activeSegments,function(activeSegment){
						activeSegment.fillColor = activeSegment.highlightColor;
					});
					this.showTooltip(activeSegments);
				});
			}
			this.calculateTotal(data);

			helpers.each(data,function(datapoint, index){
				this.addData(datapoint, index, true);
			},this);

			this.render();
		}
827801
function (data, redraw) {
		Series.prototype.setData.call(this, data, false);
		this.processData();
		this.generatePoints();
		if (pick(redraw, true)) {
			this.chart.redraw();
		} 
	}
1190366
function(data) {
      var bytesToPad, padding;
      bytesToPad = BLOCKSIZE - (data.length % BLOCKSIZE);
      padding = this.randomBytes(bytesToPad);
      return this.concat([padding, data]);
    }
952289
function(new_data, original_data) {
        var key;
        for (key in new_data) {
            if (new_data[key].constructor === Object) {
                original_data[key] = this._recursive_extend(
                    new_data[key],
                    original_data[key]
                );
            } else {
                original_data[key] = new_data[key];
            }
        }
        return original_data;
    }
806654
function generateData(numDimensions, numPoints) {
  const data = tf.tidy(() => {
    return tf.linspace(0, 1, numPoints * numDimensions)
        .reshape([numPoints, numDimensions])
        .add(tf.randomUniform([numPoints, numDimensions]));
  });
  return data;
}