parameters(params, react, initonly) {
      react = react !== false;
      const argval = this._argval = this._argval || new Parameters(),
        argops = this._argops = this._argops || [],
        deps = [];
      let name, value, n, i;
      const add = (name, index, value) => {
        if (value instanceof Operator) {
          if (value !== this) {
            if (react) value.targets().add(this);
            deps.push(value);
          }
          argops.push({
            op: value,
            name: name,
            index: index
          });
        } else {
          argval.set(name, index, value);
        }
      };
      for (name in params) {
        value = params[name];
        if (name === PULSE) {
          array$2(value).forEach(op => {
            if (!(op instanceof Operator)) {
              error('Pulse parameters must be operator instances.');
            } else if (op !== this) {
              op.targets().add(this);
              deps.push(op);
            }
          });
          this.source = value;
        } else if (isArray(value)) {
          argval.set(name, -1, Array(n = value.length));
          for (i = 0; i < n; ++i) add(name, i, value[i]);
        } else {
          add(name, -1, value);
        }
      }
      this.marshall().clear(); // initialize values
      if (initonly) argops.initonly = true;
      return deps;
    }
Sets the parameters for this operator. The parameter values are analyzed for
operator instances. If found, this operator will be added as a dependency
of the parameterizing operator. Operator values are dynamically marshalled
from each operator parameter prior to evaluation. If a parameter value is
an array, the array will also be searched for Operator instances. However,
the search does not recurse into sub-arrays or object properties.
@param {object} params - A hash of operator parameters.
@param {boolean} [react=true] - A flag indicating if this operator should
  automatically update (react) when parameter values change. In other words,
  this flag determines if the operator registers itself as a listener on
  any upstream operators included in the parameters.
@param {boolean} [initonly=false] - A flag indicating if this operator
  should calculate an update only upon its initial evaluation, then
  deregister dependencies and suppress all future update invocations.
@return {Operator[]} - An array of upstream dependencies.