Creates the function to define the exclusion zones
483599
def _hammer_function(self, x,x0,r_x0, s_x0):
        '''
        
        '''
        return norm.logcdf((np.sqrt((np.square(np.atleast_2d(x)[:,None,:]-np.atleast_2d(x0)[None,:,:])).sum(-1))- r_x0)/s_x0)
890644
@Override
	public BarrierFunction createPhase1BarrierFunction(){
		
		final int dimPh1 = dim +1;
		List<SOCPConstraintParameters> socpConstraintParametersPh1List = new ArrayList<SOCPConstraintParameters>();
 		SOCPLogarithmicBarrier bfPh1 = new SOCPLogarithmicBarrier(socpConstraintParametersPh1List, dimPh1);
 		
 		for(int i=0; i<socpConstraintParametersList.size(); i++){
 			SOCPConstraintParameters param = socpConstraintParametersList.get(i);
 			RealMatrix A = param.getA();
 			RealVector b = param.getB();
 			RealVector c = param.getC();
 			double d = param.getD();
 			
 			RealMatrix APh1 = MatrixUtils.createRealMatrix(A.getRowDimension(), dimPh1);
 			APh1.setSubMatrix(A.getData(), 0, 0); 
			RealVector bPh1 = b;
			RealVector cPh1 = new ArrayRealVector(c.getDimension()+1);
			cPh1.setSubVector(0, c);
			cPh1.setEntry(c.getDimension(), 1);
	 		double dPh1 = d;
	 		
	 		SOCPConstraintParameters paramsPh1 = new SOCPConstraintParameters(APh1.getData(), bPh1.toArray(), cPh1.toArray(), dPh1);
	 		socpConstraintParametersPh1List.add(socpConstraintParametersPh1List.size(), paramsPh1);
		}
		
		return bfPh1;
	}
871906
function generateDropZones() {
    $ColGroupContainer
      .find(DROP_ZONE).remove().end() // ensure no drop zone exists
      .find('li').each(function (idx) {
        const $this = $(this)
        $this
          .attr('draggable', 'true')
          .attr('source-idx', idx)
          .before(
            dropZoneGen(
              $this.is('li:first-of-type') ? idx - 0.25 : idx
            )
          )

        $this.is('li:last-of-type') && $this.after(dropZoneGen(idx + 0.25))
      })
  }
110902
def create_function_f_J(self):
        """"""
        return ca.Function(
            'J',
            [self.t, self.x, self.y, self.m, self.p, self.c, self.ng, self.nu],
            [ca.jacobian(self.f_x_rhs, self.x)],
            ['t', 'x', 'y', 'm', 'p', 'c', 'ng', 'nu'], ['J'], self.func_opt)
220284
function createWrapperFunction(wrapperEl, range) {
    var startNode = range.startContainer
      , endNode = range.endContainer
      , startOffset = range.startOffset
      , endOffset = range.endOffset

  return function wrapNode(node) {
    var currentRange = document.createRange()
      , currentWrapper = wrapperEl.cloneNode()

    currentRange.selectNodeContents(node)

    if (node === startNode && startNode.nodeType === 3) {
      currentRange.setStart(node, startOffset)
      startNode = currentWrapper
      startOffset = 0
    }
    if (node === endNode && endNode.nodeType === 3) {
      currentRange.setEnd(node, endOffset)
      endNode = currentWrapper
      endOffset = 1
    }

    currentRange.surroundContents(currentWrapper)
    return currentWrapper
  }
}
395516
function exclude(obj, keys) {
        var result, key;
        result = {};
        keys = keys || [];
        for (key in obj) {
            if (obj.hasOwnProperty(key)) {
                if (keys.indexOf(key) === -1) {
                    if (typeof obj[key] !== 'function') {
                        result[key] = obj[key];
                    }
                }
            }
        }
        return result;
    }
472330
function createDefinePropsMethod(_ref) {
  var enumerable = _ref.enumerable;
  var operation = enumerable ? defineEnumProp : defineProp;
  return function (argTuples, target) {
    argTuples.forEach(function (argTuple) {
      var _argTuple = _slicedToArray(argTuple, 3),
          TypeRef = _argTuple[0],
          propName = _argTuple[1],
          defaultValue = _argTuple[2];

      (0, _function.apply)(operation, [TypeRef, target, propName, defaultValue]);
    });
    return target;
  };
}
824518
function platoExcludes() {
    var excludes = '';
    excludeFileset.forEach(function (file) {
        if (isDirectory(file)) {
            excludes += file.replace(/\//g, '\/');
        } else {
            excludes += file;
        }
        excludes += '|';
    });

    if (excludes !== '') {
        return new RegExp(excludes.slice(0, -1));
    } else {
        return null;
    }
}
283827
public Exclude<Scan<T>> getOrCreateExclude()
   {
      Node node = childNode.getOrCreate("exclude");
      Exclude<Scan<T>> exclude = new ExcludeImpl<Scan<T>>(this, "exclude", childNode, node);
      return exclude;
   }
95331
def _fill_function(func, globals, defaults, dict, module, closure_values):
    
    func.__globals__.update(globals)
    func.__defaults__ = defaults
    func.__dict__ = dict
    func.__module__ = module

    cells = func.__closure__
    if cells is not None:
        for cell, value in zip(cells, closure_values):
            if value is not _empty_cell_value:
                cell_set(cell, value)

    return func
147777
function block(w, h, d){
    return function(cons, nil){
      for (var z=-d; z<=d; ++z)
        for (var y=-h; y<=h; ++y)
          for (var x=-w; x<=w; ++x)
            nil = cons(x, y, z),
            nil = cons(x, y, z);
      return nil;
    };
  }
482279
def apply(self, func, **kwargs):
        
        with np.errstate(all='ignore'):
            result = func(self.values, **kwargs)
        if not isinstance(result, Block):
            result = self.make_block(values=_block_shape(result,
                                                         ndim=self.ndim))

        return result
894458
def anonymous_function(block)
      lambda do |*args|
        # args: (this, node) v8 >= 0.10, otherwise (node)
        raise ArgumentError, "missing node" if args.empty?
        @tree[:Anonymous].new block.call(@tree, args.last)
      end
    end
1009459
def exclusion_path(cls, project, exclusion):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/exclusions/{exclusion}",
            project=project,
            exclusion=exclusion,
        )
186876
function () {
		this.resetBounds = function () {
			this.bounds = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
		};
		this.resetBounds();
	}
441446
function eliminateHoles (data, holeIndices, outerNode, dim) {
  var queue = [],
    i, len, start, end, list

  for (i = 0, len = holeIndices.length; i < len; i++) {
    start = holeIndices[i] * dim
    end = i < len - 1 ? holeIndices[i + 1] * dim : data.length
    list = linkedList(data, start, end, dim, false)
    if (list === list.next) {
      list.steiner = true
    }
    list = filterPoints(data, list)
    if (list) {
      queue.push(getLeftmost(data, list))
    }
  }

  queue.sort(function (a, b) {
    return data[a.i] - data[b.i]
  })

  // process holes from left to right
  for (i = 0; i < queue.length; i++) {
    eliminateHole(data, queue[i], outerNode)
    outerNode = filterPoints(data, outerNode, outerNode.next)
  }

  return outerNode
}
1315172
@Nonnull
    MapcodeZone restrictZoneTo(@Nonnull final Boundary area) {
        final MapcodeZone mapcodeZone = new MapcodeZone(latFractionMin, latFractionMax, lonFractionMin, lonFractionMax);
        final double latMin = area.getLatMicroDegMin() * Point.LAT_MICRODEG_TO_FRACTIONS_FACTOR;
        if (mapcodeZone.latFractionMin < latMin) {
            mapcodeZone.latFractionMin = latMin;
        }
        final double latMax = area.getLatMicroDegMax() * Point.LAT_MICRODEG_TO_FRACTIONS_FACTOR;
        if (mapcodeZone.latFractionMax > latMax) {
            mapcodeZone.latFractionMax = latMax;
        }
        if (mapcodeZone.latFractionMin < mapcodeZone.latFractionMax) {
            double lonMin = area.getLonMicroDegMin() * Point.LON_MICRODEG_TO_FRACTIONS_FACTOR;
            double lonMax = area.getLonMicroDegMax() * Point.LON_MICRODEG_TO_FRACTIONS_FACTOR;
            if ((lonMax < 0) && (mapcodeZone.lonFractionMin > 0)) {
                lonMin += (Point.MICRO_DEG_360 * Point.LON_MICRODEG_TO_FRACTIONS_FACTOR);
                lonMax += (Point.MICRO_DEG_360 * Point.LON_MICRODEG_TO_FRACTIONS_FACTOR);
            } else if ((lonMin > 1) && (mapcodeZone.lonFractionMax < 0)) {
                lonMin -= (Point.MICRO_DEG_360 * Point.LON_MICRODEG_TO_FRACTIONS_FACTOR);
                lonMax -= (Point.MICRO_DEG_360 * Point.LON_MICRODEG_TO_FRACTIONS_FACTOR);
            }
            if (mapcodeZone.lonFractionMin < lonMin) {
                mapcodeZone.lonFractionMin = lonMin;
            }
            if (mapcodeZone.lonFractionMax > lonMax) {
                mapcodeZone.lonFractionMax = lonMax;
            }
        }
        return mapcodeZone;
    }