code: def interpolate(self, factor, minGlyph, maxGlyph,
                      round=True, suppressError=True):
          
          factor = normalizers.normalizeInterpolationFactor(factor)
          if not isinstance(minGlyph, BaseGlyph):
              raise TypeError(("Interpolation to an instance of %r can not be "
                               "performed from an instance of %r.")
                              % (self.__class__.__name__,
                                 minGlyph.__class__.__name__))
          if not isinstance(maxGlyph, BaseGlyph):
              raise TypeError(("Interpolation to an instance of %r can not be "
                               "performed from an instance of %r.")
                              % (self.__class__.__name__,
                                 maxGlyph.__class__.__name__))
          round = normalizers.normalizeBoolean(round)
          suppressError = normalizers.normalizeBoolean(suppressError)
          self._interpolate(factor, minGlyph, maxGlyph,
                            round=round, suppressError=suppressError)
docs: Interpolate the contents of this glyph at location ``factor``
          in a linear interpolation between ``minGlyph`` and ``maxGlyph``.
  
              >>> glyph.interpolate(0.5, otherGlyph1, otherGlyph2)
  
          ``factor`` may be a :ref:`type-int-float` or a tuple containing
          two :ref:`type-int-float` values representing x and y factors.
  
              >>> glyph.interpolate((0.5, 1.0), otherGlyph1, otherGlyph2)
  
          ``minGlyph`` must be a :class:`BaseGlyph` and will be located at 0.0
          in the interpolation range. ``maxGlyph`` must be a :class:`BaseGlyph`
          and will be located at 1.0 in the interpolation range. If ``round``
          is ``True``, the contents of the glyph will be rounded to integers
          after the interpolation is performed.
  
              >>> glyph.interpolate(0.5, otherGlyph1, otherGlyph2, round=True)
  
          This method assumes that ``minGlyph`` and ``maxGlyph`` are completely
          compatible with each other for interpolation. If not, any errors
          encountered will raise a :class:`FontPartsError`. If ``suppressError``
          is ``True``, no exception will be raised and errors will be silently
          ignored.