code: def generate_regular_range(start, end, periods, freq):
      """
      Generate a range of dates with the spans between dates described by
      the given `freq` DateOffset.
  
      Parameters
      ----------
      start : Timestamp or None
          first point of produced date range
      end : Timestamp or None
          last point of produced date range
      periods : int
          number of periods in produced date range
      freq : DateOffset
          describes space between dates in produced date range
  
      Returns
      -------
      ndarray[np.int64] representing nanosecond unix timestamps
      """
      if isinstance(freq, Tick):
          stride = freq.nanos
          if periods is None:
              b = Timestamp(start).value
              # cannot just use e = Timestamp(end) + 1 because arange breaks when
              # stride is too large, see GH10887
              e = (
                  b
                  + (Timestamp(end).value - b) // stride * stride
                  + stride // 2
                  + 1
              )
              # end.tz == start.tz by this point due to _generate implementation
              tz = start.tz
          elif start is not None:
              b = Timestamp(start).value
              e = _generate_range_overflow_safe(
                  b, periods, stride, side="start"
              )
              tz = start.tz
          elif end is not None:
              e = Timestamp(end).value + stride
              b = _generate_range_overflow_safe(
                  e, periods, stride, side="end"
              )
              tz = end.tz
          else:
              raise ValueError(
                  "at least 'start' or 'end' should be specified "
                  "if a 'period' is given."
              )
  
          with np.errstate(over="raise"):
              # If the range is sufficiently large, np.arange may overflow
              #  and incorrectly return an empty array if not caught.
              try:
                  values = np.arange(b, e, stride, dtype=np.int64)
              except FloatingPointError:
                  xdr = [b]
                  while xdr[-1] != e:
                      xdr.append(xdr[-1] + stride)
                  values = np.array(xdr[:-1], dtype=np.int64)
  
      else:
          tz = None
          # start and end should have the same timezone by this point
          if start is not None:
              tz = start.tz
          elif end is not None:
              tz = end.tz
  
          xdr = generate_range(
              start=start, end=end, periods=periods, offset=freq
          )
  
          values = np.array([x.value for x in xdr], dtype=np.int64)
  
      return values, tz
  
imports: import numpy
  from pandas._libs.tslibs import OutOfBoundsDatetime, Timestamp
  from pandas.tseries.offsets import Tick, generate_range
label_desc: Use image node_id 1 for calling a global function with example usage: generate_regular_range(start, end, periods, freq) and returns: values,  tz