FUNCTIONS // 
FUNCTION: transform( data )
Defines the data transformation.

@private
@param {number} data - numeric stream data
@returns {number} transformed data
544288
function transform( data ) {
		var qValues;

		// Convert a comma delimited string into an array:
		data = JSON.parse( '[' + data + ']' );

		// Compute the quartiles:
		qValues = quartiles( data );

		// Return the interquartile range:
		return qValues[1] - qValues[0];
	}
1163298
function(data) {

		return data instanceof Object && (
		(this.domInstance('input', data) && data.type === 'file') ||
		('FileList' in window && data instanceof window.FileList) ||
		('File' in window && data instanceof window.File) ||
		('Blob' in window && data instanceof window.Blob));

	}
1169653
function transformData(methodRegExp) {
    var transform = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (data) {
        return data;
    };

    var re = new RegExp(methodRegExp || '.*');

    // The middleware function
    return function transformDataMiddleware(next) {
        // Checks if the call should be transformed. If yes, it applies the transform function
        function checkAndTransform(method) {
            return re.test(method) ? function (req) {
                return next[method](req).then(function (res) {
                    return Object.assign(res, { data: transform(res.data) });
                });
            } : function (req) {
                return next[method](req);
            };
        }

        // The middleware connector:
        return {
            create: checkAndTransform('create'),
            read: checkAndTransform('read'),
            update: checkAndTransform('update'),
            delete: checkAndTransform('delete')
        };
    };
}
981154
def transformArray(data, keysToSplit=[]):
    
    transformed = [ ]
    for item in data:
        transformed.append(transform(item, keysToSplit))
    return transformed
920132
function onData(W) {
        var buffer = getBuffer(W),
            full = false,
            dropVal,
            sum = 0,
            delta = 0,
            N = 0;

        /**
        * FUNCTION: onData(newVal, encoding, clbk)
        *   Data event handler. Calculates the moving sum.
        *
        * @private
        * @param {Number} newVal - streamed data value
        * @param {String} encoding
        * @param {Function} clbk - callback to invoke after finding a sum. Function accepts two arguments: [ error, chunk ].
        */
        return function onData(newVal, encoding, clbk) {
            // Fill buffer of size W
            if (!full) {
                buffer[N] = newVal;

                sum += newVal;
                N += 1;

                if (N===W) {
                    full = true;
                    this.push(sum);
                }
                clbk();
                return;
            }

            // Update buffer: (drop old value, add new)
            dropVal = buffer.shift();
            buffer.push(newVal);

            // Calculate moving sum:
            delta = newVal - dropVal;
            sum += delta;

            clbk(null, sum);
        }; // end FUNCTION onData(newVal)
    }
585577
function transform (stream, target) {
  return stream
  .pipe($.plumber(::console.error))
  .pipe($.sourcemaps.init())
    .pipe($.babel({/** see .babelrc **/}))
  .pipe($.sourcemaps.write())
  .pipe($.plumber.stop())
  .pipe(gulp.dest(target))
}
320668
function transform( data ) {
		var N = data.N,
			g;

		// Population skewness:
		g = Math.sqrt( N )*data.M3 / Math.pow( data.M2, 3/2 );

		// Sample skewness correction:
		return Math.sqrt( N*N-1)*g / (N-2);
	}
182593
async function convertStream(data, streaming) {
  if (!streaming && util.isStream(data)) {
    return stream.readToEnd(data);
  }
  if (streaming && !util.isStream(data)) {
    data = new ReadableStream({
      start(controller) {
        controller.enqueue(data);
        controller.close();
      }
    });
  }
  if (streaming === 'node') {
    data = stream.webToNode(data);
  }
  return data;
}
500071
function transformObject (type) {
  const transformed = {}

  for (let key in type) {
    transformed[key] = transformType(type[key])
  }

  return transformed
}
865179
function onData( numValues ) {
		var i = -1, buffer;

		// Initialize the buffer array used for chunking:
		buffer = new Array( numValues );

		/**
		* FUNCTION: onData( newVal, encoding, clbk )
		*	Data event handler. Chunks data.
		*
		* @private
		* @param {Number} newVal - new streamed data value
		* @param {String} encoding
		* @param {Function} clbk - callback to invoke after handling streamed data. Function accepts two arguments: [ error, chunk ].
		*/
		return function onData( newVal, encoding, clbk ) {
			i += 1;
			buffer[ i ] = newVal;
			if ( i === numValues-1 ) {
				i = -1;
				clbk( null, buffer.slice() );
				return;
			}
			clbk();
		}; // end FUNCTION onData()
	}
427321
def transform(self, data):
        
        with timer('transform %s' % self.name, logging.DEBUG):
            transformed = super(NestedUnique, self).transform(self.unnest(data))
            return transformed.reshape((len(data), self.sequence_length))
590634
def _transform(self, data, transform, step_size):
    '''
    
    '''
    if transform=='mean':
      total = sum( data )
      count = len( data )
      data = float(total)/float(count) if count>0 else 0
    elif transform=='count':
      data = len(data)
    elif transform=='min':
      data = min(data or [0])
    elif transform=='max':
      data = max(data or [0])
    elif transform=='sum':
      data = sum(data)
    elif transform=='rate':
      data = len(data) / float(step_size)
    elif callable(transform):
      data = transform(data)
    return data
37475
function (data) {
            var that = this,
                options = $.extend({}, this.options, data);
            if (options.processQueue && options.processQueue.length) {
                this._transformProcessQueue(options);
                if (this._processing === 0) {
                    this._trigger('processstart');
                }
                $.each(data.files, function (index) {
                    var opts = index ? $.extend({}, options) : options,
                        func = function () {
                            return that._processFile(opts);
                        };
                    opts.index = index;
                    that._processing += 1;
                    that._processingQueue = that._processingQueue.pipe(func, func)
                        .always(function () {
                            that._processing -= 1;
                            if (that._processing === 0) {
                                that._trigger('processstop');
                            }
                        });
                });
            }
            return this._processingQueue;
        }
23598
function onData() {
		var flg = false,
			diff,
			oldVal;

		/**
		* FUNCTION: onData( newVal, encoding, clbk )
		*	Data event handler. Calculates the difference.
		*
		* @private
		* @param {Number} newVal - new streamed data value
		* @param {String} encoding
		* @param {Function} clbk - callback to invoke after calculating the difference. Function accepts two arguments: [ error, chunk ].
		*/
		return function onData( newVal, encoding, clbk ) {
			if ( flg ) {
				diff = newVal - oldVal;
				oldVal = newVal;
				clbk( null, diff );
				return;
			}
			// Do not calculate a difference for the first streamed value...
			oldVal = newVal;
			flg = true;
			clbk();
		}; // end FUNCTION onData()
	}
695443
function(data) {
		if( typeof data == "string" ) {
			var transformed = {};
			$.each(data.split(/\s/), function() {
				transformed[this] = true;
			});
			data = transformed;
		}
		return data;
	}
1309703
def transform(self, data):
        

        if not self._get("fitted"):
            raise RuntimeError("`transform` called before `fit` or `fit_transform`.")

        data = data.copy()
        output_column_prefix = self._get("output_column_prefix")

        if output_column_prefix is None:
            prefix = ""
        else:
            prefix = output_column_prefix + '.'

        transform_function = self._get("transform_function")

        feature_columns = self._get("features")
        feature_columns = _internal_utils.select_feature_subset(data, feature_columns)

        for f in feature_columns:
            data[prefix + f] = transform_function(data[f])

        return data
1028318
public void transform(double data[], int rowspan) {
    checkData(data,rowspan);
    for(int i=0; i<nrows; i++){
      rowFFT.transform(data,i*rowspan,2); }
    for(int j=0; j<ncols; j++){
      colFFT.transform(data,2*j,rowspan); }}