//  [python]
def integral_compare(self, f_bin='all'):
        """
          Cumulative bin envelope integral comparison for two signals

          :param f_bin: frequency bins to compare, Supported arguments are :
          'all', 'bass', 'mid', 'highmid', 'uppermid', 'presence', 'brillance'
          :return: None

          __ Dual SoundPack Method __
          Plots the cumulative integral plot of specified frequency bins
          and their difference as surfaces
          """

        # Case when plotting all the frequency bins
        if f_bin == 'all':
            fig, axs = plt.subplots(3, 2, figsize=(16, 16))
            axs = axs.reshape(-1)

            # get the bins frequency values
            self.bin_strings = self.sounds[0].bins.keys()
            bins1 = self.sounds[0].bins.values()
            bins2 = self.sounds[1].bins.values()

            for signal1, signal2, bin_string, ax in zip(bins1, bins2, self.bin_strings, axs):
                # Compute the log time and envelopes integrals
                log_envelope1, log_time1 = signal1.normalize().log_envelope()
                log_envelope2, log_time2 = signal2.normalize().log_envelope()
                env_range1 = np.arange(2, len(log_envelope1), 1)
                env_range2 = np.arange(2, len(log_envelope2), 1)
                integral1 = np.array([np.trapz(log_envelope1[:i], log_time1[:i]) for i in env_range1])
                integral2 = np.array([np.trapz(log_envelope2[:i], log_time2[:i]) for i in env_range2])
                time1 = log_time1[2:len(log_time1):1]
                time2 = log_time2[2:len(log_time2):1]

                # resize arrays to match shape
                common_len = min(len(time1), len(time2))
                time1 = time1[:common_len]
                time2 = time2[:common_len]
                integral1 = integral1[:common_len]
                integral2 = integral2[:common_len]
                # Normalize
                max_value = np.max(np.hstack([integral1, integral2]))
                integral1 /= max_value
                integral2 /= max_value

                # plot the integral area curves
                ax.fill_between(time1, integral1, label=self.sounds[0].name, alpha=0.4)
                ax.fill_between(time2, -integral2, label=self.sounds[1].name, alpha=0.4)
                ax.fill_between(time2, integral1 - integral2, color='g', label='int diff', alpha=0.6)
                ax.set_xlabel('time (s)')
                ax.set_ylabel('mirror cumulative power (normalized)')
                ax.set_xscale('log')
                ax.set_title(bin_string)
                ax.legend()
                ax.grid('on')

            plt.tight_layout()

        elif f_bin in self.bin_strings:

            # Compute the log envelopes and areau curves
            signal1 = self.sounds[0].bins[f_bin]
            signal2 = self.sounds[1].bins[f_bin]
            log_envelope1, log_time1 = signal1.normalize().log_envelope()
            log_envelope2, log_time2 = signal2.normalize().log_envelope()
            integral1 = np.array([np.trapz(log_envelope1[:i], log_time1[:i]) for i in np.arange(2, len(log_envelope1), 1)])
            integral2 = np.array([np.trapz(log_envelope2[:i], log_time2[:i]) for i in np.arange(2, len(log_envelope2), 1)])
            time1 = log_time1[2:len(log_time1):1]
            time2 = log_time2[2:len(log_time2):1]

            # resize arrays to match shape
            common_len = min(len(time1), len(time2))
            time1 = time1[:common_len]
            time2 = time2[:common_len]
            integral1 = integral1[:common_len]
            integral2 = integral2[:common_len]
            # Normalize
            max_value = np.max(np.hstack([integral1, integral2]))
            integral1 /= max_value
            integral2 /= max_value

            fig, ax = plt.subplots(figsize=(8, 6))
            ax.fill_between(time1, integral1, label=self.sounds[0].name, alpha=0.4)
            ax.fill_between(time2, -integral2, label=self.sounds[1].name, alpha=0.4)
            ax.fill_between(time2, integral1 - integral2, color='g', label='int diff', alpha=0.6)

            ax.set_xlabel('time (s)')
            ax.set_ylabel('mirror cumulative power (normalized)')
            ax.set_xscale('log')
            ax.set_title(f_bin)
            ax.legend(loc='upper left')
            ax.grid('on')

        else:
            print('invalid frequency bin')