disclose infinities
542795
function uninfinite(u, src) {
  for (var i = 0; i < src.length; i++) {
    if (src[i] === Infinity) u[i] = 255
  }
  return u
}
141727
def get_neg_infinity(dtype):
    
    if issubclass(dtype.type, (np.floating, np.integer)):
        return -np.inf

    if issubclass(dtype.type, np.complexfloating):
        return -np.inf - 1j * np.inf

    return NINF
246907
function() {

      // 1 / 0 = Infinity and 1 / Infinity = 0
      if (this['isZero']()) {
        return Complex['INFINITY'];
      }

      if (this['isInfinite']()) {
        return Complex['ZERO'];
      }

      var a = this['re'];
      var b = this['im'];

      var d = a * a + b * b;

      return new Complex(a / d, -b / d);
    }
1371554
function (a, b) {
            if (!b.pos || !a.pos) {
                return (a.pos ? -Infinity : Infinity);
            }
            var result = b.pos.z - a.pos.z;
            return (result ? result : (b.pos.y - a.pos.y));
        }
101387
function pointFpMultiply(k) {
    if(this.isInfinity()) return this;
    if(k.signum() == 0) return this.curve.getInfinity();

    var e = k;
    var h = e.multiply(new BigInteger("3"));

    var neg = this.negate();
    var R = this;

    var i;
    for(i = h.bitLength() - 2; i > 0; --i) {
	R = R.twice();

	var hBit = h.testBit(i);
	var eBit = e.testBit(i);

	if (hBit != eBit) {
	    R = R.add(hBit ? this : neg);
	}
    }

    return R;
}
186876
function () {
		this.resetBounds = function () {
			this.bounds = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
		};
		this.resetBounds();
	}
314548
function reportInfiniteRepetition( ast, session ) {

    const check = session.buildVisitor( {
        zero_or_more( node ) {

            if ( ! ast.alwaysConsumesOnSuccess( node.expression ) ) {

                session.error(
                    "Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
                    node.location
                );

            }

        },

        one_or_more( node ) {

            if ( ! ast.alwaysConsumesOnSuccess( node.expression ) ) {

                session.error(
                    "Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
                    node.location
                );

            }

        }
    } );

    check( ast );

}
246880
function isNum(value, impure) {
      var isNb = typeof value == 'number';
      return impure ? isNb : isNb && isFinite(value);
    }
1135160
def mask_nonfinite(self):
        """"""
        self.mask = np.logical_and(self.mask, (np.isfinite(self.intensity)))
985580
function getDelimitersFinalMeans(text, innerCode) {
    const codeStart = text.indexOf(innerCode)
    const codeEnd = codeStart + innerCode.length
    return [text.slice(0, codeStart), text.slice(codeEnd)]
}
1336904
function PageResultInfinite(items, totalCount, requestIndex, nextIndex, baseUrl) {
      this.items = items != null ? items : [];
      this.totalCount = totalCount != null ? totalCount : 0;
      this.requestIndex = requestIndex;
      this.nextIndex = nextIndex != null ? nextIndex : null;
      this.baseUrl = baseUrl != null ? baseUrl : null;
      this.toRest = __bind(this.toRest, this);

    }
28408
function (f, a, b, fa, fc, fb, options) {
    var h = b - a, c = (a + b) / 2, fd = f((a + c) / 2), fe = f((c + b) / 2), Q1 = (h / 6) * (fa + 4 * fc + fb), Q2 = (h / 12) * (fa + 4 * fd + 2 * fc + 4 * fe + fb), Q = Q2 + (Q2 - Q1) / 15;

    options.calls = options.calls + 2;

    // Infinite or Not-a-Number function value encountered
    if (!isFinite(Q)) {
        options.warn = Math.max(options.warn, 3);
        return Q;
    }

    // Maximum function count exceeded; singularity likely
    if (options.calls > options.maxCalls) {
        options.warn = Math.max(options.warn, 2);
        return Q;
    }

    // Accuracy over this subinterval is acceptable
    if (Math.abs(Q2 - Q) <= options.tolerance) {
        return Q;
    }

    // Minimum step size reached; singularity possible
    if (Math.abs(h) < options.minStep || c === a || c === b) {
        options.warn = Math.max(options.warn, 1);
        return Q;
    }

    // Otherwise, divide the interval into two subintervals
    return quadstep(f, a, c, fa, fd, fc, options) + quadstep(f, c, b, fc, fe, fb, options);
}
1153189
function(a, b) {

      var z = new Complex(a, b);

      // 0 / 0 = NaN and Infinity / Infinity = NaN
      if ((this['isZero']() && z['isZero']()) || (this['isInfinite']() && z['isInfinite']())) {
        return Complex['NAN'];
      }

      // Infinity / 0 = Infinity
      if (this['isInfinite']() || z['isZero']()) {
        return Complex['INFINITY'];
      }

      // 0 / Infinity = 0
      if (this['isZero']() || z['isInfinite']()) {
        return Complex['ZERO'];
      }

      a = this['re'];
      b = this['im'];

      var c = z['re'];
      var d = z['im'];
      var t, x;

      if (0 === d) {
        // Divisor is real
        return new Complex(a / c, b / c);
      }

      if (Math.abs(c) < Math.abs(d)) {

        x = c / d;
        t = c * x + d;

        return new Complex(
                (a * x + b) / t,
                (b * x - a) / t);

      } else {

        x = d / c;
        t = d * x + c;

        return new Complex(
                (a + b * x) / t,
                (b - a * x) / t);
      }
    }
254749
function() {

      // asech(c) = log((1+sqrt(1-c^2))/c)

      var a = this['re'];
      var b = this['im'];

      if (this['isZero']()) {
        return Complex['INFINITY'];
      }

      var d = a * a + b * b;
      return (d !== 0)
              ? new Complex(
                      a / d,
                      -b / d).acosh()
              : new Complex(
                      (a !== 0) ? a / 0 : 0,
                      (b !== 0) ? -b / 0 : 0).acosh();
    }
667691
def cardinality_for(*args)
      args.inject([]) {|results,arg|
        result = :many 
        result = :one if arg.singularize == arg
        results << result        
      }
    end
737173
function lnpost(theta, x, y) {
  var lp = lnprior(theta);
  if (!isFinite(lp)) {
    return -Infinity;
  }
  return lp + lnlike(theta, x, y);
}
766852
def inferSequence(exp, sequenceId, sequences, objectName=0):
  """"""
  # Create the (loc, feat) pairs for this sequence for column 0.
  objectSensations = {
    0: [pair for pair in sequences[sequenceId]]
  }

  inferConfig = {
    "object": sequenceId,
    "numSteps": len(objectSensations[0]),
    "pairs": objectSensations,
  }

  inferenceSDRs = sequences.provideObjectToInfer(inferConfig)
  exp.infer(inferenceSDRs, objectName=objectName)