Whether or not the domain contains a finite number of points.

        :type: `bool`
183005
def is_finite(self):
        
        return not np.isinf(self.min) and not np.isinf(self.max)
1258829
private boolean contains(Vector3f test, List<Vector3f> points) {
        int i;
        int j;
        boolean result = false;
        for (i = 0, j = points.size() - 1; i < points.size(); j = i++) {
            if (((points.get(i).z > test.z) != (points.get(j).z > test.z))
                    && (test.x < (points.get(j).x - points.get(i).x)
                    * (test.z - points.get(i).z) / (points.get(j).z - points.get(i).z)
                    + points.get(i).x)) {
                result = !result;
            }
        }
        return result;
    }
476507
public boolean isMultiPoint() {
    boolean mp = true;
    if (this == UNDEFINED) { mp = false; }
    else if (this == NULL) { mp = false; }
    else if (this == POINT) { mp = false; }
    return mp;
  }
1345850
function(points, bbox) {
        for (var i = 0; i < points.length; i++) {
            if (this.bboxContainsPoint(points[i], bbox))
                return true;
        }
        return false;
    }
85429
def contains?(x, y)
      points_distance(x1, y1, x, y) <= length &&
      points_distance(x2, y2, x, y) <= length &&
      (((@y2 - @y1) * x - (@x2 - @x1) * y + @x2 * @y1 - @y2 * @x1).abs / length) <= 0.5 * @width
    end
1084507
public boolean containsPoint2D(double[] v) {
    assert (v.length == 2);
    final double testx = v[0];
    final double testy = v[1];
    boolean c = false;

    Iterator<double[]> it = points.iterator();
    double[] pre = points.get(points.size() - 1);
    while(it.hasNext()) {
      final double[] cur = it.next();
      final double curx = cur[0], cury = cur[1];
      final double prex = pre[0], prey = pre[1];
      if(((cury > testy) != (prey > testy))) {
        if((testx < (prex - curx) * (testy - cury) / (prey - cury) + curx)) {
          c = !c;
        }
      }
      pre = cur;
    }
    return c;
  }
631710
def boolean(self):
        
        try:
            return self._boolean
        except AttributeError:
            nbits = len(self.bits)
            boolean = numpy.zeros((self.size, nbits), dtype=bool)
            for i, sample in enumerate(self.value):
                boolean[i, :] = [int(sample) >> j & 1 for j in range(nbits)]
            self._boolean = Array2D(boolean, name=self.name,
                                    x0=self.x0, dx=self.dx, y0=0, dy=1)
            return self.boolean
859719
def values(self):
        
        if self.is_finite:
            return np.arange(self.min, self.max + 1, dtype = self.dtype)
        else:
            return self.example_point
109537
def contains_point?(pt)
      pt.x.between?(left, left + width - 1) &&
        pt.y.between?(top, top + height - 1)
    end
674855
@Pure
	public boolean containsPoint(Point2D<?, ?> point) {
		if (point == null) {
			return false;
		}
		for (int i = 0; i < getPointCount(); ++i) {
			final Point2d cur = getPointAt(i);
			if (cur.epsilonEquals(point, MapElementConstants.POINT_FUSION_DISTANCE)) {
				return true;
			}
		}
		return false;
	}
190430
def contains_all(self, array):
        """"""
        dtype = getattr(array, 'dtype', None)
        if dtype is None:
            dtype = np.result_type(*array)
        return is_real_dtype(dtype)
1082812
public boolean contains(int xp, int yp) {
		if (xp < x) {
			return false;
		}
		if (yp < y) {
			return false;
		}
		if (xp >= x+width) {
			return false;
		}
		if (yp >= y+height) {
			return false;
		}
		
		return true;
	}
1176193
def contains?(pt)
      ((pt.lat >= min_lat) && (pt.lat <= max_lat) && (pt.lon >= min_lon) && (pt.lon <= max_lon))
    end
65824
public static boolean containsNaN(DoubleTuple tuple)
    {
        for (int i=0; i<tuple.getSize(); i++)
        {
            if (Double.isNaN(tuple.get(i)))
            {
                return true;
            }
        }
        return false;
    }
674612
def has_overflow(self, params):
        
        is_not_finite = 0
        for param in params:
            if param.grad_req != 'null':
                grad = param.list_grad()[0]
                is_not_finite += mx.nd.contrib.isnan(grad).sum()
                is_not_finite += mx.nd.contrib.isinf(grad).sum()
        # NDArray is implicitly converted to bool
        if is_not_finite == 0:
            return False
        else:
            return True
200403
def has_bounds(self):
        """"""
        bounds = self.bounds
        if bounds in (None, [None, None]):
            return False
        for ib, bound in enumerate(bounds):
            if bound is not None:
                sign_ = 2 * ib - 1
                for bound_i in bound:
                    if bound_i is not None and sign_ * bound_i < np.inf:
                        return True
        return False
918093
def is_finite(self):
        """"""
        return (self.num_stores == 2 and
                self.state == 0 and self.has_cell(0) and
                self.input == 1 and self.has_input(1))