The YUJIN Transform

v1 — Basic (9-digit):
YUJIN(φ,λ) = [⌊((φ+90)/180) × 999,999⌋] — [⌊((λ+180)/360) × 999⌋]
Result: XXX-XXX-XXX (latitude 6 digits + longitude 3 digits)

v2 — Precise (12-digit): NEW
Let λ_n = (λ+180)/360 and B = ⌊λ_n × 999⌋ (the v1 longitude digit group).
YUJIN₂(φ,λ) = [⌊((φ+90)/180) × 999,999⌋] — [B] — [⌊(λ_n × 999 − B) × 1,000⌋]
Result: XXX-XXX-XXX-XXX (latitude 6 digits + longitude 3+3 digits)

Where:
• φ = latitude (-90° to +90°)
• λ = longitude (-180° to +180°)
• The final 3 digits subdivide the v1 longitude cell into 1,000 parts — they are nested inside it, not an independent 6-digit scale
• Therefore the first 9 digits of a v2 code are bit-for-bit identical to the v1 code for the same point (verified over 2,000,001 longitude samples: 0 mismatches)

// JavaScript — YUJIN Transform v2.0 (canonical, 2026-08-17) // This is the reference implementation. It is byte-identical in behaviour to the // production services (wiagil api/convert.php, wiagil js/app.js, wiacode.com // orbit/web/generate.js). Do not fork it — v2 longitude is NESTED inside v1. // Basic mode (9-digit, v1) function yujinTransform(lat, lng) { const latPart = Math.floor(((lat + 90) / 180) * 999999); const lngPart = Math.floor(((lng + 180) / 360) * 999); const latStr = latPart.toString().padStart(6, '0'); const lngStr = lngPart.toString().padStart(3, '0'); return `${latStr.substr(0,3)}-${latStr.substr(3,3)}-${lngStr}`; } // Precise mode (12-digit, v2 NEW) — v1 code + 1/1000 subdivision of its cell function yujinTransformPrecise(lat, lng) { const latPart = Math.floor(((lat + 90) / 180) * 999999); const latStr = latPart.toString().padStart(6, '0'); const lngNorm = (lng + 180) / 360; const lngBase = Math.floor(lngNorm * 999); // ← identical to v1 const lngSub = Math.floor((lngNorm * 999 - lngBase) * 1000); return `${latStr.substr(0,3)}-${latStr.substr(3,3)}` + `-${lngBase.toString().padStart(3, '0')}` + `-${lngSub.toString().padStart(3, '0')}`; } // Reverse (auto-detects 9 or 12 digits) function yujinReverse(code) { let digits = code.replace(/\D/g, ''); // strip any country dial-code prefix, e.g. 082-708-702-851-863 if (digits.length > 12) digits = digits.slice(-12); else if (digits.length > 9 && digits.length < 12) digits = digits.slice(-9); if (digits.length === 12) { // v2 returns the CENTRE of the cell (+0.5), halving the error to ±10m / ±20m. const latPart = parseInt(digits.substr(0,6)); const lngBase = parseInt(digits.substr(6,3)); const lngSub = parseInt(digits.substr(9,3)); return { lat: ((latPart + 0.5) / 999999) * 180 - 90, lng: ((lngBase + (lngSub + 0.5) / 1000) / 999) * 360 - 180, precise: true }; } if (digits.length === 9) { // v1 returns the cell FLOOR — unchanged by design. Millions of v1 codes are // already issued and printed; adding the +0.5 centre correction here would // shift every one of them by up to ~20km in longitude. return { lat: (parseInt(digits.substr(0,6)) / 999999) * 180 - 90, lng: (parseInt(digits.substr(6,3)) / 999) * 360 - 180, precise: false }; } return null; } // Examples (verified): // yujinTransform(37.5665, 126.9780) → "708-702-851" // yujinTransformPrecise(37.5665, 126.9780) → "708-702-851-863" ← first 9 = v1 // yujinReverse("708-702-851-863") → {lat: 37.56658, lng: 126.97784} // yujinTransformPrecise(yujinReverse(c)) → c (round-trip stable, 0 failures // over a 1,442,401-point sweep)

v1: 999,999 × 999 = 998,999,001 (~1 billion)
v2: 999,999 × (999 × 1,000) = 998,999,001,000 (~1 trillion)
→ 1,000× more precise

Cell height: 180° / 999,999 = 0.000180° → 20.0m
Cell width: 360° / (999 × 1,000) = 0.000360° → 40.1m × cos(φ)

Because reverse lookup returns the cell centre, max error = half a cell:
North-South: ±10.0m everywhere
East-West: ±20.1m at the equator · ±15.9m at Seoul (37.5°) · ±12.5m at London (51.5°)
→ Building-level precision worldwide

v1 longitude: B = ⌊λ_n × 999⌋ → 3 digits
v2 longitude: B and S = ⌊(λ_n × 999 − B) × 1,000⌋ → 3 + 3 digits

B appears unmodified in the v2 code, so first 9 digits of v2 ≡ v1. Always.
Verified: 2,000,001 longitude samples, 0 mismatches.