docs: def compute_hist(self, bins=None, density=True, folded=False, weight="duration"):
          """
          Computes histogram from the pitch data in Pitch object (pitch), and creates
          a Data object (pypeaks).
  
          :param bins: Refers to number of bins in the histogram, determines the granularity.
          If it is not set, the number of bins which gives the highest granularity is chosen
          automatically.
          :param density: defaults to True, which means the histogram will be a normalized one.
          :param folded: defaults to False. When set to True, all the octaves are folded to one.
          :param weight: It can be one of the 'duration' or 'instance'. In the latter case, make
          sure that the pitch object has the pitch values discretized.
          """
          #Step 1: get the right pitch values
          assert isinstance(self.pitch_obj.pitch, np.ndarray)
          valid_pitch = self.pitch_obj.pitch
          valid_pitch = [i for i in valid_pitch if i > -10000]
          if folded:
              valid_pitch = map(lambda x: int(x % 1200), valid_pitch)
  
          #Step 2: based on the weighing scheme, compute the histogram
          if weight == "duration":
              #Step 2.1 set the number of bins (if not passed)
              if not bins:
                  bins = max(valid_pitch) - min(valid_pitch)
              n, bin_edges = np.histogram(valid_pitch, bins, density=density)
              bin_centers = 0.5 * (bin_edges[1:] + bin_edges[:-1])
              self.histogram = Data(bin_centers, n)
          elif weight == "instance":
              n = {}
              i = 1
              while i < len(valid_pitch) - 1:
                  if (valid_pitch[i] - valid_pitch[i - 1] != 0) and \
                          (valid_pitch[i + 1] - valid_pitch[i] == 0):
                      if valid_pitch[i] in n.keys():
                          n[valid_pitch[i]] += 1
                      else:
                          n[valid_pitch[i]] = 1
                  i += 1
              n = n.items()
              n.sort(key=lambda x: x[0])
              n = np.array(n)
              self.histogram = Data(n[:, 0], n[:, 1])
  
              median_diff = np.median(np.diff(n[:, 0]))
              bin_edges = [n[0, 0] - median_diff/2]
              bin_edges.extend(median_diff/2 + n[:, 0])
              n[:, 1] = n[:, 1]/(n[:, 1].sum()*np.diff(bin_edges))
              self.histogram = Data(n[:, 0], n[:, 1], default_smooth=False)