test two numbers equal to the lowest precision - r

Question

Given two arrays of numbers, I wish to test whether pairs of numbers are equal to the precision of the least precise of each pair of numbers.
This problem originates from validating the reproduction of presented numbers. I have been given a set of (rounded) numbers, an attempt to replicate them has produced more precise numbers. I need to report whether the less precise numbers are rounded versions of the more precise numbers.
For example, the following pair of vectors should all return true
input_a = c(0.01, 2.2, 3.33, 44.4, 560, 700) # less precise values provided
input_b = c(0.011, 2.22, 3.333, 44.4000004, 555, 660) # more precise replication
because when rounded to the lowest pair-wise precision the two vectors are equal:
pair_wise_precision = c(2, 1, 2, 1, -1, -2)
input_a_rounded = rep(NA, 6)
input_b_rounded = rep(NA, 6)
for(ii in 1:6){
input_a_rounded[ii] = round(input_a[ii], pair_wise_precision[ii])
input_b_rounded[ii] = round(input_b[ii], pair_wise_precision[ii])
}
all(input_a_rounded == input_b_rounded)
# TRUE
# ignoring machine precision
However, I need to do this without knowing the pair-wise precision.
Two approaches I have identified:
Test a range of rounding and accept the two values are equal if any level of rounding returns a match
Pre-calculate the precision of each input
However, both of these approaches feel cumbersome. I have seen in another language the option to round one number of match the precision of another number (sorry, can't recall which). But I can not find this functionality in R.
(This is not a problem about floating point numbers or inaccuracy due to machine precision. I am comfortable handling these separately.)
Edit in response to comments:
We can assume zeros are not significant figures. So, 1200 is considered rounded to the nearest 100, 530 is rounded to the nearest 10, and 0.076 is rounded to the nearest thousandth.
We stop at the precision of the least precise value. So, if comparing 12300 and 12340 the least precise value is rounded to the nearest 100, hence we compare round(12300, -2) and round(12340, -2). If comparing 530 and 570, then the least precise value is rounded to the nearest 10, hence we compare round(530, -1) and round(570, -1).

Answer 1

You could divide by the exponents of 10, remove trailing zeroes and calculate pmin of nchar where you subtract 2 for the whole number and the decimal point. This gives you the precision vector p with which you round the bases of a and b and multiply back the exponents and check if identical.
f <- \(a, b) {
ae <- 10^floor(log10(a))
be <- 10^floor(log10(b))
al <- a/ae
bl <- b/be
p <- pmin(nchar(gsub('0+$', '', format(al))), nchar(gsub('0+$', '', format(bl)))) - 2L
identical(mapply(round, al, p)*ae, mapply(round, bl, p)*be)
}
f(a, b)
# [1] TRUE
Data:
a <- c(0.01, 2.2, 3.33, 44.4, 555, 700)
b <- c(0.011, 2.22, 3.333, 44.4000004, 560, 660)

Answer 2

My initial thinking followed #jay.sf's approach to analyse values as numeric. However, considering the values as character provides another way to determine rounding:
was_rounded_to = function(x){
x = as.character(x)
location_of_dot = as.numeric(regexpr("\\.", x))
ref_point = ifelse(location_of_dot < 0, nchar(x), location_of_dot)
last_non_zero = sapply(gregexpr("[1-9]", x), max)
return(last_non_zero - ref_point)
}
# slight expansion in test cases
a <- c(0.01, 2.2, 3.33, 44.4, 555, 700, 530, 1110, 440, 3330)
b <- c(0.011, 2.22, 3.333, 44.4000004, 560, 660, 570, 1120, 4400, 3300)
rounding = pmin(was_rounded_to(a), was_rounded_to(b))
mapply(round, a, digits = rounding) == mapply(round, b, digits = rounding)
Special case: If the numbers only differ by rounding, then it is easier to determine the magnitude by examining the difference:
a <- c(0.01, 2.2, 3.33, 44.4, 555, 700)
b <- c(0.011, 2.22, 3.333, 44.4000004, 560, 660)
abs_diff = abs(a-b)
mag = -floor(log10(abs_diff ) + 1e-15)
mapply(round, a, digits = mag - 1) == mapply(round, b, digits = mag - 1)
However, this fails when the numbers differ by more than rounding. For example: a = 530 and b = 540 will incorrectly round both 530 and 540 to 500.