code: def sample(self, bqm, beta_range=None, num_reads=10, num_sweeps=1000):
          
  
          # input checking
          # h, J are handled by the @ising decorator
          # beta_range, sweeps are handled by ising_simulated_annealing
          if not isinstance(num_reads, int):
              raise TypeError("'samples' should be a positive integer")
          if num_reads < 1:
              raise ValueError("'samples' should be a positive integer")
  
          h, J, offset = bqm.to_ising()
  
          # run the simulated annealing algorithm
          samples = []
          energies = []
          for __ in range(num_reads):
              sample, energy = ising_simulated_annealing(h, J, beta_range, num_sweeps)
              samples.append(sample)
              energies.append(energy)
  
          response = SampleSet.from_samples(samples, Vartype.SPIN, energies)
          response.change_vartype(bqm.vartype, offset, inplace=True)
          return response
docs: Sample from low-energy spin states using simulated annealing.
  
          Args:
              bqm (:obj:`.BinaryQuadraticModel`):
                  Binary quadratic model to be sampled from.
  
              beta_range (tuple, optional): Beginning and end of the beta schedule
                  (beta is the inverse temperature) as a 2-tuple. The schedule is applied
                  linearly in beta. Default is chosen based on the total bias associated
                  with each node.
  
              num_reads (int, optional, default=10):
                  Number of reads. Each sample is the result of a single run of
                  the simulated annealing algorithm.
  
              num_sweeps (int, optional, default=1000):
                  Number of sweeps or steps.
  
          Returns:
              :obj:`.SampleSet`
  
          Note:
              This is a reference implementation, not optimized for speed
              and therefore not an appropriate sampler for benchmarking.