code: def mp_a_trous(C0, wavelet_filter, scale, core_count):
      
  
      # Creates an array which may be accessed by multiple processes.
  
      shared_array_base = mp.Array(ctypes.c_float, C0.shape[0]**2, lock=False)
      shared_array = np.frombuffer(shared_array_base, dtype=ctypes.c_float)
      shared_array = shared_array.reshape(C0.shape)
      shared_array[:,:] = C0
  
      # Division of the problem and allocation of processes to cores.
  
      processes = []
  
      for i in range(core_count):
          process = mp.Process(target = mp_a_trous_kernel, args = (shared_array, wavelet_filter, scale, i,
                                                       C0.shape[0]//core_count, 'row',))
          process.start()
          processes.append(process)
  
      for i in processes:
          i.join()
  
      processes = []
  
      for i in range(core_count):
          process = mp.Process(target = mp_a_trous_kernel, args = (shared_array, wavelet_filter, scale, i,
                                                       C0.shape[1]//core_count, 'col',))
          process.start()
          processes.append(process)
  
      for i in processes:
          i.join()
  
      return shared_array
docs: This is a reimplementation of the a trous filter which makes use of multiprocessing. In particular,
      it divides the input array of dimensions NxN into M smaller arrays of dimensions (N/M)xN, where M is the
      number of cores which are to be used.
  
      INPUTS:
      C0              (no default):   The current array which is to be decomposed.
      wavelet_filter  (no default):   The filter-bank which is applied to the components of the transform.
      scale           (no default):   The scale at which decomposition is to be carried out.
      core_count      (no default):   The number of CPU cores over which the task should be divided.
  
      OUTPUTS:
      shared_array                    The decomposed array.