code: def integrate(self, rate, timestep):
          
          self._fast_normalise()
          rate = self._validate_number_sequence(rate, 3)
  
          rotation_vector = rate * timestep
          rotation_norm = np.linalg.norm(rotation_vector)
          if rotation_norm > 0:
              axis = rotation_vector / rotation_norm
              angle = rotation_norm
              q2 = Quaternion(axis=axis, angle=angle)
              self.q = (self * q2).q
              self._fast_normalise()
docs: Advance a time varying quaternion to its value at a time `timestep` in the future.
  
          The Quaternion object will be modified to its future value.
          It is guaranteed to remain a unit quaternion.
  
          Params:
  
          rate: numpy 3-array (or array-like) describing rotation rates about the
              global x, y and z axes respectively.
          timestep: interval over which to integrate into the future.
              Assuming *now* is `T=0`, the integration occurs over the interval
              `T=0` to `T=timestep`. Smaller intervals are more accurate when
              `rate` changes over time.
  
          Note:
              The solution is closed form given the assumption that `rate` is constant
              over the interval of length `timestep`.