Returns true if its arguments are monotonically increaing values; false otherwise.
496134
function() {
      var count = _.size(arguments);
      if (count === 1) return true;
      if (count === 2) return arguments[0] < arguments[1];

      for (var i = 1; i < count; i++) {
        if (arguments[i-1] >= arguments[i]) {
          return false;
        }
      }

      return true;
    }
749932
def issequence(arg):
    """"""
    string_behaviour = (
        isinstance(arg, six.string_types) or
        isinstance(arg, six.text_type))
    list_behaviour = hasattr(arg, '__getitem__') or hasattr(arg, '__iter__')
    return not string_behaviour and list_behaviour
911067
public boolean has(int... values) {
		long p = pur(values[0]);
		for (int i = 1, l = values.length; i < l; i++) {
			p += pur(values[i]);
		}
		return p == (this.delegate & p);
	}
618671
public boolean isSingle() {
    // assume simplified
    if ((positiveQueryList.size() == 1) && (negativeQueryList.size() == 0)) {
      return true;
    } else if ((positiveQueryList.size() == 0)
        && (negativeQueryList.size() == 1)) {
      return true;
    }
    return false;
  }
726627
def does_coord_increase_w_index(arr):
    
    diff = np.diff(arr)
    if not np.all(np.abs(np.sign(diff))):
        raise ValueError("Array is not monotonic: {}".format(arr))
    # Since we know its monotonic, just test the first value.
    return bool(diff[0])
447053
public boolean isActive() {
		final long now = System.currentTimeMillis();
		final long start = values.getStart();
		final long end = start + values.getLeft();
		// TODO : Ensure predicate consistency.
		return now >= start && now <= end;
	}
227111
def non_increasing(values):
    """"""
    return all(x >= y for x, y in zip(values, values[1:]))
680299
def is_valid(cls, arg):
        
        return (isinstance(arg, (int, long)) and (arg >= 0)) or \
            isinstance(arg, str)
816178
boolean valuesAreTheSameAsDefault()
    {
        if (getDefaultValues() == null || getDefaultValues().size() == 0)
            return false;
        if (getValues() == null || getValues().size() == 0)
            return false;
        if (getDefaultValues().size() != getValues().size())
            return false;
        for (int v = 0; v < getDefaultValues().size(); v++)
            if (!getDefaultValues().get(v).equals(getValues().get(v)))
                return false;
        return true;
    }
1314555
public function isConvergent()
	{
		for ($i=$this->interval->getStart(); $i<$this->interval->getEnd(); $i++)
		{
			$diff = abs ($this->getValue ($i+1) - $this->getValue ($i));
			if (!$old_diff) $old_diff = $diff;
			else
			{
				if ($diff >= $old_diff)
					return false;
			}
		}
		return true;
	}
763397
public function isMultiDimensional(): bool
    {
        if (sizeof($this->bag) === 0) {
            return false;
        }

        return count($this->bag) !== count($this->bag, COUNT_RECURSIVE);
    }
667846
public boolean isNonsingular ()
  {
    for (int j = 0; j < m_nCols; j++)
      if (m_aLU[j][j] == 0)
        return false;
    return true;
  }
1311145
@Pure
	public static boolean isESRINaN(float value) {
		return Float.isInfinite(value) || Float.isNaN(value) || value <= ESRI_NAN;
	}
634935
@Override
    public boolean isWithin(double delta)
    {
        readLock.lock();
        try
        {
            if (average.getCount() > min.getInitialSize())
            {
                return (deviation() < delta);
            }
            else
            {
                return false;
            }
        }
        finally
        {
            readLock.unlock();
        }
    }
138079
public static boolean isZero(long[] v) {
    for(int i = 0; i < v.length; i++) {
      if(v[i] != 0) {
        return false;
      }
    }
    return true;
  }
575346
def is_neg_unate(self, vs=None):
        
        """
        vs = self._expect_vars(vs)
        basis = self.support - set(vs)
        maxcov = [PC_ONE] * (1 << len(basis))
        # Test whether table entries are monotonically decreasing
        for cf in self.iter_cofactors(vs):
            for i, item in enumerate(cf.pcdata):
                if maxcov[i] == PC_ZERO and item == PC_ONE:
                    return False
                maxcov[i] = item
        return True
672029
static boolean allPositive(int[] input, int start, int length) {
        for (int i = length - 1, index = start; i >= 0; i--, index++) {
            if (input[index] <= 0) {
                return false;
            }
        }

        return true;
    }