// Excel arithmetic is decimal at 15 significant digits. Double::to_string
// gives the shortest roundtrip decimal, which we round as a digit string so
// ROUND(2.675, 2) = 2.68 instead of the naive binary 2.67.
struct Dec {
neg : Bool
digits : String // normalized: no leading/trailing zeros; "0" for zero
exp : Int // value = d0.d1d2... * 10^exp
}
let digit_chars : Array[Char] = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
fn dec_zero() -> Dec {
{ neg: false, digits: "0", exp: 0 }
}
fn dec_of_double(d : Double) -> Dec {
if d == 0.0 {
return dec_zero()
}
let chars = Array::from_iter(d.to_string().iter())
let n = chars.length()
let mut i = 0
let mut neg = false
if chars[0] == '-' {
neg = true
i = 1
}
let mut e_pos = n
for j in i.. lead + 1 && ds[end - 1] == '0' {
end -= 1
}
{ neg, digits: String::from_array(ds[lead:end]), exp }
}
// mode: 0 = half away from zero, 1 = away (up), 2 = truncate (down).
// keep = number of leading digits to retain; may be <= 0.
fn round_dec(d : Dec, keep : Int, mode : Int) -> Dec {
if d.digits == "0" || keep >= d.digits.length() {
return d
}
let n = d.digits.length()
let ds : Array[Int] = []
for ch in d.digits.iter() {
ds.push(ch.to_int() - '0'.to_int())
}
if keep <= 0 {
let decision = if keep == 0 { ds[0] } else { 0 }
let up = match mode {
0 => decision >= 5
1 => true
_ => false
}
if !up {
return dec_zero()
}
return { neg: d.neg, digits: "1", exp: d.exp + 1 - keep }
}
let mut tail_nonzero = false
for j in keep.. ds[keep] >= 5
1 => tail_nonzero
_ => false
}
let mut kept : Array[Int] = []
for j in 0..= 0 {
if kept[j] == 9 {
kept[j] = 0
j -= 1
} else {
kept[j] += 1
break
}
}
if j < 0 {
let nk : Array[Int] = [1]
for x in kept {
nk.push(x)
}
kept = nk
exp += 1
}
}
while kept.length() > 1 && kept[kept.length() - 1] == 0 {
let _ = kept.pop()
}
let mut s = ""
for v in kept {
s = s + digit_chars[v].to_string()
}
{ neg: d.neg, digits: s, exp }
}
fn dec_to_double(d : Dec) -> Double {
if d.digits == "0" {
return 0.0
}
let mut s = if d.neg { "-" } else { "" }
s = s + d.digits.substring(start=0, end=1)
if d.digits.length() > 1 {
s = s + "." + d.digits.substring(start=1)
}
s = s + "e" + d.exp.to_string()
@string.parse_double(s[:]) catch { _ => 0.0 }
}
fn dec_to_fixed(d : Dec) -> String {
let point = d.exp + 1
let n = d.digits.length()
if point <= 0 {
let mut s = "0."
for _ in 0..<(-point) {
s = s + "0"
}
return s + d.digits
}
if point >= n {
let mut s = d.digits
for _ in 0..<(point - n) {
s = s + "0"
}
return s
}
d.digits.substring(start=0, end=point) + "." + d.digits.substring(start=point)
}
/// Excel 隐式数字→文本(`&`/CONCAT 用的 General 格式):先舍入到 15 位有效数字,
/// 十进制指数在 [-18, 19] 内用定点表示,否则科学计数;科学计数尾数去尾零,定点整数补零。
pub fn number_to_text(d : Double) -> String {
let dec = round_dec(dec_of_double(d), 15, 0)
if dec.digits == "0" {
return "0"
}
let sign = if dec.neg { "-" } else { "" }
if dec.exp >= 20 || dec.exp <= -19 {
let mut mant = dec.digits.substring(start=0, end=1)
if dec.digits.length() > 1 {
mant = mant + "." + dec.digits.substring(start=1)
}
let e = dec.exp
let esign = if e < 0 { "-" } else { "+" }
let ea = if e < 0 { -e } else { e }
return sign + mant + "E" + esign + ea.to_string()
}
sign + dec_to_fixed(dec)
}
/// Excel 十进制舍入(先归一到 15 位有效数字再舍入,避免二进制浮点尾差)。
/// `digits` 为保留小数位(负数舍入到十/百…位);`mode`:0=ROUND(四舍五入)、
/// 1=ROUNDUP(远离零)、2=ROUNDDOWN(趋向零)。
pub fn round_excel(d : Double, digits : Int, mode : Int) -> Double {
if d == 0.0 {
return 0.0
}
let dec = round_dec(dec_of_double(d), 15, 0)
let keep = dec.exp + 1 + digits
dec_to_double(round_dec(dec, keep, mode))
}