Returns the number of members in the domain if it
        `is_finite`, otherwise, returns `np.inf`.

        :type: ``int`` or ``np.inf``
174344
def n_members(self):
        
        if self.is_finite:
            return int(self.max - self.min + 1)
        else:
            return np.inf
1303049
def p_sizeof(p):
    
    if TYPE.to_type(p[3].lower()) is not None:
        p[0] = make_number(TYPE.size(TYPE.to_type(p[3].lower())),
                           lineno=p.lineno(3))
    else:
        entry = SYMBOL_TABLE.get_id_or_make_var(p[3], p.lineno(1))
        p[0] = make_number(TYPE.size(entry.type_), lineno=p.lineno(3))
519463
def num(self, count=None, show=None):  # (;$count,$show)
        
        if count is not None:
            try:
                self.persistent_count = int(count)
            except ValueError:
                raise BadNumValueError
            if (show is None) or show:
                return str(count)
        else:
            self.persistent_count = None
        return ""
1039091
private static int getMonomerCountFromMonomerNotation(MonomerNotation monomerNotation) {
    int multiply;
    try {
      multiply = Integer.parseInt(monomerNotation.getCount());
      if (multiply < 1) {
        multiply = 1;
      }
    } catch (NumberFormatException e) {
      multiply = 1;
    }

    if (monomerNotation instanceof MonomerNotationGroup) {
      return 1 * multiply;
    }
    if (monomerNotation instanceof MonomerNotationList) {
      int count = 0;
      for (MonomerNotation unit : ((MonomerNotationList) monomerNotation).getListofMonomerUnits()) {
        count += getMonomerCountFromMonomerNotation(unit);
      }
      return count * multiply;
    }

    if (monomerNotation instanceof MonomerNotationUnitRNA) {
      int count = 0;
      for (MonomerNotationUnit unit : ((MonomerNotationUnitRNA) monomerNotation).getContents()) {
        count += getMonomerCountFromMonomerNotation(unit);
      }
      return count * multiply;
    }
    return 1 * multiply;
  }
1143549
def min(self):
        
        return int(self._min) if not np.isinf(self._min) else self._min
749653
def number(self):
        
        return int(math.ceil(self.total_size / float(self.size)))
961277
def count(fn, coll):
    
    return len([x for x in coll if fn(x) is True])
343268
def fib(n):
    """"""
    v = n.value
    return v if v < 2 else fib2(PythonInt(v-1)) + fib(PythonInt(v-2))
218890
def getNumberTLD():
    
    total = 0
    for typeTld in TLD.keys():
        total+= len(TLD[typeTld])
    return total
829924
def getCountGT(self, item):
        """"""
        index = bisect.bisect_right(self._list, item)
        return len(self._list) - index
203812
def count_account(self, domain):
        
        selector = domain.to_selector()
        cos_list = self.request_list('CountAccount', {'domain': selector})
        ret = []

        for i in cos_list:
            count = int(i['_content'])
            ret.append((zobjects.ClassOfService.from_dict(i),  count))

        return list(ret)
541639
def count(self, table):
        
        if self._operator is None and self._operands is None:
            return self._get_table_len(table)

        return np.count_nonzero(self.mask(table))
1094797
def range(self, count):
        
        if count <= 1:
            raise ValueError("Range size must be greater than 1.")
        dom = self._domain
        distance = dom[-1] - dom[0]
        props = [ self(dom[0] + distance * float(x)/(count-1))
            for x in range(count) ]
        return props
305959
def count(self):
        

        try:
            return self.object_list.count()
        except (AttributeError, TypeError):
            # AttributeError if object_list has no count() method.
            # TypeError if object_list.count() requires arguments
            # (i.e. is of type list).
            return len(self.object_list)
538444
def tuple_index(self, n):
        ''''''
        return n.args and n.args[-1].type == 'index' and general_type(n.args[-1].sequence.pseudo_type) == 'Tuple' and\
               n.args[-1].index.type == 'int' and\
               (n.args[-1].index.value == -1 or n.args[-1].index.value == len(n.args[-1].sequence.pseudo_type) - 2)
858663
def number_of_singleton_referents(self):
        
        if self.__dict__['referential_domain']:
            ct = 0
            for i in self.iter_singleton_referents():
                ct += 1
            return ct
        else:
            raise Exception("self.referential_domain must be defined")
1174234
def size(self):
        
        if self._instrs is []:
            return None

        return sum([instr.size for instr in self._instrs])