code: def parseFloat(self, words):
          
          def pointFloat(words):
              m = re.search(r'(.*) point (.*)', words)
              if m:
                  whole = m.group(1)
                  frac = m.group(2)
                  total = 0.0
                  coeff = 0.10
                  for digit in frac.split(' '):
                      total += coeff * self.parse(digit)
                      coeff /= 10.0
  
                  return self.parseInt(whole) + total
              return None
  
          def fractionFloat(words):
              m = re.search(r'(.*) and (.*)', words)
              if m:
                  whole = self.parseInt(m.group(1))
                  frac = m.group(2)
  
                  # Replace plurals
                  frac = re.sub(r'(\w+)s(\b)', '\g<1>\g<2>', frac)
  
                  # Convert 'a' to 'one' (e.g., 'a third' to 'one third')
                  frac = re.sub(r'(\b)a(\b)', '\g<1>one\g<2>', frac)
  
                  split = frac.split(' ')
  
                  # Split fraction into num (regular integer), denom (ordinal)
                  num = split[:1]
                  denom = split[1:]
  
                  while denom:
                      try:
                          # Test for valid num, denom
                          num_value = self.parse(' '.join(num))
                          denom_value = self.parse(' '.join(denom))
                          return whole + float(num_value) / denom_value
                      except:
                          # Add another word to num
                          num += denom[:1]
                          denom = denom[1:]
              return None
  
          # Extract "one point two five"-type float
          result = pointFloat(words)
          if result:
              return result
  
          # Extract "one and a quarter"-type float
          result = fractionFloat(words)
          if result:
              return result
  
          # Parse as integer
          return self.parseInt(words)
docs: Convert a floating-point number described in words to a double.
  
          Supports two kinds of descriptions: those with a 'point' (e.g.,
          "one point two five") and those with a fraction (e.g., "one and
          a quarter").
  
          Args:
              words (str): Description of the floating-point number.
  
          Returns:
              A double representation of the words.