Look for other numeration in line.
333473
def find_numeration_more(line):
    """"""
    # First, attempt to use marked-up titles
    patterns = (
        re_correct_numeration_2nd_try_ptn1,
        re_correct_numeration_2nd_try_ptn2,
        re_correct_numeration_2nd_try_ptn3,
        re_correct_numeration_2nd_try_ptn4,
    )
    for pattern in patterns:
        match = pattern.search(line)
        if match:
            info = match.groupdict()
            series = extract_series_from_volume(info['vol'])
            if not info['vol_num']:
                info['vol_num'] = info['vol_num_alt']
            if not info['vol_num']:
                info['vol_num'] = info['vol_num_alt2']
            return {'year': info.get('year', None),
                    'series': series,
                    'volume': info['vol_num'],
                    'page': info['page'] or info['jinst_page'],
                    'page_end': info['page_end'],
                    'len': len(info['aftertitle'])}

    return None
1326767
function(other) {
        var comps = ["a", "b", "c", "d"],
            i, len;

        for (i=0, len=comps.length; i < len; i++) {
            if (this[comps[i]] < other[comps[i]]) {
                return -1;
            } else if (this[comps[i]] > other[comps[i]]) {
                return 1;
            }
        }

        return 0;
    }
196885
def _number(text):
    '''
    
    '''
    if text.isdigit():
        return int(text)
    try:
        return float(text)
    except ValueError:
        return text
1203483
def find_one(self):
        
        num = quotient = 0
        while num < self._len:
            chunk = self.data[quotient]
            if chunk & self.one_mask:
                remainder = 0
                while remainder < self.width and num < self._len:
                    item = (chunk >> remainder) & 3
                    if item == PC_ONE:
                        return num
                    remainder += 2
                    num += 1
            else:
                num += (self.width >> 1)
            quotient += 1
        return None
1226363
def number(self):
        """"""
        number = ''
        while self.char is not None and self.char.isdigit():
            number += self.char
            self.advance()

        if self.char == '.':
            number += self.char
            self.advance()

            while self.char is not None and self.char.isdigit():
                number += self.char
                self.advance()

            token = Token(Nature.FLOAT_NUMBER, number)

        else:
            token = Token(Nature.INT_NUMBER, number)

        return token
374409
def numval(token):
    """"""
    if token.type == 'INTEGER':
        return int(token.value)
    elif token.type == 'FLOAT':
        return float(token.value)
    else:
        return token.value
320224
def get_not_num(self, seq, num=0):
        ''''''
        ind = next((i for i, x in enumerate(seq) if x != num), None)
        if ind == None:
            return self.board_size
        else:
            return ind
235308
def num_to_ith(num):
    """"""
    value             = str(num)
    before_last_digit = value[-2]
    last_digit        = value[-1]
    if len(value) > 1 and before_last_digit == '1': return value +'th'
    if last_digit == '1': return value + 'st'
    if last_digit == '2': return value + 'nd'
    if last_digit == '3': return value + 'rd'
    return value + 'th'
463991
protected function checkMissingAmount()
    {
        // Check if we are missing an amount and, if so, add a line for it.
        $this->completeLineTotals();
        $areTotalsEqual = $this->areTotalsEqual();
        if ($areTotalsEqual === false) {
            $this->addMissingAmountLine();
        }
    }
76589
def index(self, pkt_num):
        """"""
        int_check(pkt_num)
        for counter, datagram in enumerate(self.datagram):
            if pkt_num in datagram.index:
                return counter
        return None
450882
def next_line(self):
        """"""
        self.line = next(self.lines)  # Will raise StopIteration when there are no more lines
        self.values = self.line.split()
274279
def compare(self, other):
        """"""

        self._validate_compare_parameters(other=other)

        return_list = []
        for idx, digit in enumerate(other):
            dwa = DigitWordAnalysis(
                index=idx,
                digit=digit,
                match=(digit == self._word[idx]),
                in_word=(self._word.count(digit) > 0),
                multiple=(self._word.count(digit) > 1)
            )
            return_list.append(dwa)

        return return_list
954245
def compute_checksum(line):
    """"""
    return sum((int(c) if c.isdigit() else c == '-') for c in line[0:68]) % 10
1330562
def line_and_column(text, position):
    """"""
    position_counter = 0
    for idx_line, line in enumerate(text.splitlines(True)):
        if (position_counter + len(line.rstrip())) >= position:
            return (idx_line, position - position_counter)
        else:
            position_counter += len(line)
219057
def _number_finder(s, regex, numconv):
    """"""

    # Split.  If there are no splits, return now
    s = regex.split(s)
    if len(s) == 1:
        return tuple(s)

    # Now convert the numbers to numbers, and leave strings as strings
    s = remove_empty(s)
    for i in range(len(s)):
        try:
            s[i] = numconv(s[i])
        except ValueError:
            pass

    # If the list begins with a number, lead with an empty string.
    # This is used to get around the "unorderable types" issue.
    if not isinstance(s[0], six.string_types):
        return [''] + s
    else:
        return s
1224308
private int _findInlineToken (final String sIn, final int nStart, final EMarkToken eToken)
  {
    int nPos = nStart;
    while (nPos < sIn.length ())
    {
      if (_getToken (sIn, nPos) == eToken)
        return nPos;
      nPos++;
    }
    return -1;
  }
171202
def r_num(obj):
    """"""
    if isinstance(obj, (list, tuple)):
        it = iter
    else:
        it = LinesIterator
    dataset = Dataset([Dataset.FLOAT])
    return dataset.load(it(obj))