如何处理实数开区间？寻求非近似的精准实现方法

Hey there! I get it—working with real-number open intervals ((x, y), excluding boundaries) is critical for avoiding errors like division by zero, and your current oInt() function is a solid start for discrete steps, but it’s inherently approximate since it relies on enumerating points from seq(). Let’s dive into precision-focused solutions tailored to different use cases:

1. Generate Strictly Open Interval Random Samples #

If you’re looking to sample values guaranteed to stay within (x, y) (like your sample(x1, 7) example), R’s built-in runif() function is perfect. It generates values from a continuous uniform distribution over (min, max)—mathematically, the probability of hitting exactly x or y is 0, so you never have to worry about boundary values:

# Sample 7 values strictly in (0, 1)
runif(7, min = 0, max = 1)
# Example output: [1] 0.234 0.789 0.112 0.567 0.901 0.345 0.678

2. Create an Open Interval Validator #

If you need to check if a value (or vector of values) falls strictly within (x, y), build a simple helper function to perform strict comparisons—this avoids any approximation from discrete sequences:

is_in_open_interval <- function(val, lower_bound, upper_bound) {
  # Returns TRUE only if val is strictly greater than lower AND strictly less than upper
  val > lower_bound & val < upper_bound
}

# Example usage:
test_vals <- c(0, 0.5, 1, 0.999)
is_in_open_interval(test_vals, 0, 1)
# Output: [1] FALSE  TRUE FALSE  TRUE

You can also use this to filter existing vectors directly:

filtered_vals <- test_vals[is_in_open_interval(test_vals, 0, 1)]
# Output: [1] 0.500 0.999

3. Optimized Discrete Open Interval Sequence #

If you still need a discrete sequence of points strictly within (x, y) (like your original oInt()), skip the post-filtering and generate the sequence directly from x + res to y - res. This is more efficient and eliminates any chance of accidentally including boundaries:

oInt_precise <- function(x, y, res = 1) {
  # Check if step size allows for valid points in the interval
  if (x + res >= y - res) {
    stop("Step size is too large to generate points within (x, y)")
  }
  seq(from = x + res, to = y - res, by = res)
}

# Test with your original parameters
x1 <- oInt_precise(0, 1, 0.001)
x1[c(1:2, length(x1)-1, length(x1))]
# Output: [1] 0.001 0.002 0.998 0.999

Why Your Original Approach Was Approximate #

The core issue with seq(x, y, res)[!seq(x,y,res) %in% c(x,y)] is that seq() generates discrete points, so you’re always working with a finite subset of the infinite real numbers in (x, y). The solutions above either leverage continuous random sampling, strict logical checks, or direct sequence generation to avoid this inherent approximation.

内容的提问来源于stack exchange，提问作者jay.sf