关于「东南亚台日定价矩阵落地:四类产品、更新节奏与试算器规格」,《购买力平价与多币种尾数定价》给出的定量结论是什么?

结论:回避规则:若市场设了 avoid,删掉整数部分含有这些数字的格点。黄金切片(实现后必须逐项比对 p70 打印的切片):USD 在 40 到 70 之间是 49.00、49.90、49.99、59.00、59.90、59.99、69.00、69.90、69.99;MYR 在 120 到 160 之间是 129.00、129.90、139.00、139.90、149.00、149.90、159.00、159.90;TWD 从 980 到 1,299 是 980、988、990、999、1,080、1,088、1,090、1,099、1,180、1,188、1,190、1,199、1,280、1,288、1,290、1,299;JPY 在 4,980 到 6,000 之间每一百一个 80 尾,从 4,980 到 5,980;MYR 的整数格点从 900.00 到 1,200.00 每 50 一格;JPY 的整数格点从 30,000 到 40,000 每 1,000 一格。

数据口径:书中的汇率与价格水平都是写明的样本假设,不是实时数据;税费、标价与价格歧视的法规只写一般框架,不是法律或税务意见。 第八章让一个虚构牌卡品牌从 49 美元出发走完四步,最终价格是美国 49.00 美元、马来西亚 RM 149.00(被套利带从 RM 129.90 提上来)、新加坡 S$ 59.90、台湾 NT$ 1,080、日本 ¥5,580;典藏礼盒五地美元等值价的最大最小之比只有 1.1344,日常牌卡是 1.4536;模拟的汇率路径让日本的毛利率跌到 0.5433,最先触发复核;在虚构流量下,单个市场要分辨一成的毛利差距需要 97 到 257 周,所以测价只测大的决定,五地合并分析。

English version

对照数据表

下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库与结论吻合的打印值: 1080, 1088, 1090, 1099, 1180, 1188

sample FX, PLI, fees, costs and tax parameters are assumptions, not live data or tax advice
== deck: P0 49.00 USD, everyday lattice, beta 0.6, margin floor 0.55, fee 0.084, band 0.03 x + 12.00 + 3.00
mkt cur hard FX tier floor PRICE USD equiv margin edge code
US USD49.00 49.00 33.72 49.00 49.00 0.690 0.4531 TIER/EXACT
MY MYR216.58 130.53 91.15 149.00 33.71 0.725 0.0212 BAND/UP
SG SGD65.17 59.53 37.59 59.90 45.04 0.718 0.5935 TIER/UP
TW TWD1,548.40 1,045.89 970.39 1,080 34.18 0.596 0.1130 TIER/UP
JP JPY7,301.00 5,585.86 5,457.72 5,580 37.45 0.560 0.0224 TIER/DOWN
USD-equivalent spread: max - min15.29, max / min = 1.454
== report: P0 29.00 USD, everyday lattice, beta 0.8, margin floor 0.55, fee 0.084, band 0.03 x + 0 + 8.00
mkt cur hard FX tier floor PRICE USD equiv margin edge code
US USD29.00 29.00 1.21 29.00 29.00 0.981 22.9076 TIER/EXACT
MY MYR128.18 65.25 5.83 99.00 22.40 0.973 0.0819 BAND/UP
SG SGD38.57 34.19 1.77 39.00 29.32 0.980 20.9951 TIER/UP
TW TWD916.40 543.11 40.43 680 21.52 0.973 0.0395 BAND/UP
JP JPY4,321.00 3,023.63 200.65 3,180 21.34 0.972 0.0309 BAND/UP
USD-equivalent spread: max - min7.98, max / min = 1.374
== course: P0 199.00 USD, everyday lattice, beta 0.8, margin floor 0.55, fee 0.084, band 0.03 x + 0 + 15.00
mkt cur hard FX tier floor PRICE USD equiv margin edge code
US USD199.00 199.00 29.11 199.00 199.00 0.934 5.8357 TIER/EXACT
MY MYR879.58 447.76 140.00 789.90 178.71 0.920 0.0004 BAND/UP WARN_KNIFE_EDGE
SG SGD264.67 234.59 42.56 239.00 179.70 0.920 4.6163 TIER/UP
TW TWD6,288.40 3,726.86 970.39 5,680 179.75 0.923 0.0062 BAND/UP WARN_KNIFE_EDGE
JP JPY29,651.00 20,748.34 4,815.63 26,680 179.06 0.919 0.0023 BAND/UP WARN_KNIFE_EDGE
USD-equivalent spread: max - min20.29, max / min = 1.114
== collector: P0 280 USD, round lattice, beta 0.6, margin floor 0.65, fee 0.084, band 0.03 x + 25.00 + 3.00
mkt cur hard FX tier floor PRICE USD equiv margin edge code
US USD280.00 280.00 237.06 280.00 280.00 0.704 0.1812 TIER/EXACT
查看完整验算程序
# Chapter 7. p70: Reference run of the multi-currency pricing engine (matrix spec v1.0), four product classes.
# FX, PLI, fees, costs and tax rates are SAMPLE ASSUMPTIONS shared with chapters 1 and 8 (assumed, not
# live data, not tax advice; check the latest official notices before any real use).
# Engine for one product over the markets US, MY, SG, TW, JP (US is the anchor market):
#   1 tier      T = P0 * fx * F(pli ** beta).limit_denominator(10^9)         (a display price)
#   2 lattice   nearest lattice point to T by |ln(p / T)|, ties to the lower point
#   3 floor     incl: R = p / (1 + t) - phi p      excl: R = p - phi p (1 + t)      (phi = payment + platform)
#               margin = (R - cost) / R >= M  ->  floor = cost (1 + s) / (1 - M) / den,
#               den = 1 / (1 + t) - phi (incl) or 1 - phi (1 + t) (excl); den <= 0 -> REJECT_FEE_STACK
#               cost = (unit cost USD + fixed fee USD) * fx; s = optional FX stress (default 0)
#               if p < floor: p = smallest lattice point >= floor
#   4 band      u = p / fx; a pair (a, b) breaches when u_a - u_b > sigma * u_b + parcel + hours;
#               take the pair with the largest excess, raise the lower market b to the smallest lattice
#               point >= (u_a - parcel - hours) / (1 + sigma) * fx_b * (1 + s); repeat until no breach.
#               Never raise the anchor (-> REJECT_BAND_ANCHOR); if the raised b ends above a in USD
#               (lattice too coarse) -> REJECT_BAND_OVERSHOOT.
# Lattices: everyday  USD x9.00 x9.90 x9.99 | MYR, SGD x9.00 x9.90 | TWD last two digits 80 88 90 99 |
#           JPY last two digits 80;  round  multiples of USD 10, SGD 10, MYR 50, TWD 100, JPY 1,000.
#           a market's optional 'avoid' drops points whose whole part contains any of its digits.
# Units: smallest unit 0.01 for USD, SGD, MYR and 1 for TWD, JPY; WARN_KNIFE_EDGE when edge < 0.01.
import hashlib
import math
from fractions import Fraction as F

ROUND_STEP = {"USD": F(10), "SGD": F(10), "MYR": F(50), "TWD": F(100), "JPY": F(1000)}
QUANT = {"USD": F(1, 100), "SGD": F(1, 100), "MYR": F(1, 100), "TWD": F(1), "JPY": F(1)}
MARKETS = ("US", "MY", "SG", "TW", "JP")
CUR = {"US": "USD", "MY": "MYR", "SG": "SGD", "TW": "TWD", "JP": "JPY"}
FX = {"US": "1", "MY": "4.42", "SG": "1.33", "TW": "31.6", "JP": "149.0"}      # SAMPLE, not live
PLI = {"US": "1.00", "MY": "0.43", "SG": "0.86", "TW": "0.52", "JP": "0.64"}    # SAMPLE, US = 1
MODE = {"US": "excl", "MY": "incl", "SG": "incl", "TW": "incl", "JP": "incl"}
SHIP = {"US": "6.50", "MY": "1.10", "SG": "3.20", "TW": "4.60", "JP": "6.20"}   # USD per unit, sample
BOX_SHIP = {"US": "14.00", "MY": "3.00", "SG": "6.00", "TW": "8.00", "JP": "10.00"}  # insured, sample
GOODS_TAX = {"US": "0", "MY": "0", "SG": "0.09", "TW": "0.05", "JP": "0.10"}     # sample parameters
DIGITAL_TAX = {"US": "0", "MY": "0.08", "SG": "0.09", "TW": "0.05", "JP": "0.10"}


def fmt(cur, v):
    return "{:,.2f}".format(float(v)) if QUANT[cur] < 1 else "{:,}".format(int(v))


def lattice(cur, family, hi, avoid=""):
    pts = set()
    if family == "round":
        step = ROUND_STEP[cur]
        pts |= {step * j for j in range(1, int(hi / step) + 2)}
    elif cur in ("USD", "MYR", "SGD"):
        for t in range(0, int(hi) // 10 + 2):
            pts |= {F(10 * t + 9), F(10 * t + 9) + F("0.90")}
            if cur == "USD":
                pts.add(F(10 * t + 9) + F("0.99"))
    elif cur == "TWD":
        for h in range(0, int(hi) // 100 + 2):
            pts |= {F(100 * h + e) for e in (80, 88, 90, 99)}
    else:
        for h in range(0, int(hi) // 100 + 2):
            pts.add(F(100 * h + 80))
    return sorted(p for p in pts if 0 < p <= max(hi, 10) and not any(d in str(int(p)) for d in avoid))


def nearest(cur, family, x, avoid=""):
    pts = lattice(cur, family, 3 * x, avoid)
    return min(pts, key=lambda p: (abs(math.log(p / x)), p)) if pts else None


def up_from(cur, family, x, avoid=""):
    pts = [p for p in lattice(cur, family, 3 * x, avoid) if p >= x]
    return min(pts) if pts else None


def run(prod, mk):
    """prod: product dict; mk: {market: dict(fx, pli, tax, mode, cost_usd)}. Returns {market: result}."""
    try:
        p0, beta, m, phi = F(prod["p0"]), float(prod["beta"]), F(prod["floor"]), F(prod["fee"])
        sig, parcel, hours = F(prod["spread"]), F(prod["parcel"]), F(prod["hours"])
        s, fam = F(prod.get("stress", "0")), prod["family"]
        rows = {k: (CUR[k], F(v["fx"]), float(v["pli"]), F(v["tax"]), v["mode"],
                    F(v["cost_usd"]) + F(prod.get("fixed_usd", "0"))) for k, v in mk.items()}
        avoids = {k: v.get("avoid", "") for k, v in mk.items()}
    except (KeyError, ValueError, ZeroDivisionError):
        return {"*": {"code": "REJECT_INPUT"}}
    if (p0 <= 0 or not 0 <= beta <= 1 or not 0 <= m < 1 or phi < 0 or min(sig, parcel, hours) < 0
            or not 0 <= s < 1 or fam not in ("everyday", "round") or "US" not in rows
            or any(e <= 0 or lv <= 0 or t < 0 or md not in ("incl", "excl") or c < 0
                   for _, e, lv, t, md, c in rows.values())):
        return {"*": {"code": "REJECT_INPUT"}}
    out = {}
    for k, (cur, e, lv, t, md, c) in rows.items():
        tier = p0 * e * F(lv ** beta).limit_denominator(10 ** 9)
        den = (1 / (1 + t) - phi) if md == "incl" else (1 - phi * (1 + t))
        if den <= 0:
            return {k: {"code": "REJECT_FEE_STACK"}}
        floor = c * e * (1 + s) / (1 - m) / den
        p = nearest(cur, fam, tier, avoids[k])
        why = "TIER"
        if p is not None and p < floor:
            p, why = up_from(cur, fam, floor, avoids[k]), "FLOOR"
        if p is None:
            return {k: {"code": "REJECT_NO_LATTICE"}}
        out[k] = {"cur": cur, "fx": e, "tax": t, "mode": md, "cost": c * e, "tier": tier,
                  "floor": floor, "price": p, "why": why, "need": F(0)}
    for _ in range(4 * len(out)):
        usd = {k: r["price"] / r["fx"] for k, r in out.items()}
        breach = sorted(((usd[a] - usd[b] - sig * usd[b] - parcel - hours, a, b) for a in out for b in out
                         if usd[a] - usd[b] > sig * usd[b] + parcel + hours), reverse=True)
        if not breach:
            break
        excess, a, b = breach[0]
        if b == "US":
            return {b: {"code": "REJECT_BAND_ANCHOR", "excess": excess, "pair": a + ">" + b}}
        need = (usd[a] - parcel - hours) / (1 + sig) * out[b]["fx"] * (1 + s)
        new = up_from(out[b]["cur"], fam, need, avoids[b])
        if new is None:
            return {b: {"code": "REJECT_NO_LATTICE"}}
        if new / out[b]["fx"] > usd[a]:
            return {b: {"code": "REJECT_BAND_OVERSHOOT", "pair": a + ">" + b}}
        out[b].update(price=new, why="BAND", need=need)
    for k, r in out.items():
        p, t = r["price"], r["tax"]
        n, pay = (p / (1 + t), p) if r["mode"] == "incl" else (p, p * (1 + t))
        rev = n - phi * pay
        r["margin"] = (rev - r["cost"]) / rev
        r["usd"] = p / r["fx"]
        r["edge"] = p / max(r["floor"], r["need"]) - 1
        r["code"] = r["why"] + "/" + ("EXACT" if p == r["tier"] else ("UP" if p > r["tier"] else "DOWN"))
    return out


def markets(tax, cost_usd, **over):
    mk = {k: {"fx": FX[k], "pli": PLI[k], "tax": tax[k], "mode": MODE[k], "cost_usd": cost_usd[k]}
          for k in MARKETS}
    for key, val in over.items():                 # e.g. JP_fx="160"
        k, f = key.split("_", 1)
        mk[k][f] = val
    return mk


PRODUCTS = {  # sample, fictional brand Mistharbor; deck = the chapter 8 everyday deck
    "deck": ({"p0": "49.00", "family": "everyday", "beta": "0.6", "floor": "0.55", "fee": "0.084",
              "spread": "0.03", "parcel": "12.00", "hours": "3.00"},
             GOODS_TAX, {k: str(F("7.40") + F(SHIP[k])) for k in MARKETS}),
    "report": ({"p0": "29.00", "family": "everyday", "beta": "0.8", "floor": "0.55", "fee": "0.084",
                "spread": "0.03", "parcel": "0", "hours": "8.00"},
               DIGITAL_TAX, dict.fromkeys(MARKETS, "0.50")),
    "course": ({"p0": "199.00", "family": "everyday", "beta": "0.8", "floor": "0.55", "fee": "0.084",
                "spread": "0.03", "parcel": "0", "hours": "15.00"},
               DIGITAL_TAX, dict.fromkeys(MARKETS, "12.00")),
    "collector": ({"p0": "280", "family": "round", "beta": "0.6", "floor": "0.65", "fee": "0.084",
                   "spread": "0.03", "parcel": "25.00", "hours": "3.00"},
                  GOODS_TAX, {k: str(F("62.00") + F(BOX_SHIP[k])) for k in MARKETS}),
}


def product_run(name, prod_over=None, **mk_over):
    prod, tax, cost = PRODUCTS[name]
    prod = dict(prod, **(prod_over or {}))
    return run(prod, markets(tax, cost, **mk_over))


if __name__ == "__main__":
    print("sample FX, PLI, fees, costs and tax parameters are assumptions, not live data or tax advice")
    canon = []
    for name, (prod, _, _) in PRODUCTS.items():
        print("== {}: P0 {} USD, {} lattice, beta {}, margin floor {}, fee {}, band {} x + {} + {}".format(
            name, prod["p0"], prod["family"], prod["beta"], prod["floor"], prod["fee"], prod["spread"],
            prod["parcel"], prod["hours"]))
        print("   mkt cur     hard FX        tier       floor       PRICE  USD equiv  margin    edge  code")
        res = product_run(name)
        for k in MARKETS:
            r = res[k]
            canon.append("{}|{}|{}".format(name, k, fmt(r["cur"], r["price"])))
            print("   {}  {} {:>11} {:>11} {:>11} {:>11} {:>10.2f} {:>7.3f} {:>7.4f}  {}{}".format(
                k, r["cur"], "{:,.2f}".format(float(F(prod["p0"]) * r["fx"])),
                "{:,.2f}".format(float(r["tier"])), "{:,.2f}".format(float(r["floor"])),
                fmt(r["cur"], r["price"]), float(r["usd"]), float(r["margin"]), float(r["edge"]),
                r["code"], " WARN_KNIFE_EDGE" if r["edge"] < F(1, 100) else ""))
        u = [float(r["usd"]) for r in res.values()]
        print("   USD-equivalent spread: max - min = {:.2f}, max / min = {:.3f}".format(
            max(u) - min(u), max(u) / min(u)))
    digest = hashlib.sha256("\n".join(canon).encode("ascii")).hexdigest()[:16]
    print("golden matrix fingerprint (sha256 of class|market|price lines, first 16 hex): " + digest)
    print("lattice golden slices:")
    for cur, fam, a, b in (("USD", "everyday", 40, 70), ("MYR", "everyday", 120, 160),
                           ("SGD", "everyday", 50, 70), ("TWD", "everyday", 980, 1300),
                           ("JPY", "everyday", 4980, 6000), ("MYR", "round", 900, 1200),
                           ("JPY", "round", 30000, 40000)):
        pts = [fmt(cur, v) for v in lattice(cur, fam, b) if a <= v <= b]
        for i in range(0, len(pts), 10):
            print("   {} {:<8} ".format(cur, fam) + " ".join(pts[i:i + 10]))

唯一数据源与引用

范雅福(Fan, Y.). (2026). 《跨国购买力平价畸变、多币种心理尾数映射与东南亚台日定价矩阵母典》第 7 章「东南亚台日定价矩阵落地:四类产品、更新节奏与试算器规格」(版本 0.1.0). 5D Library. DOI 待发布

DOI 待发布 · 专著页正式发布后上线(本站暂无专著页) · 5DL-B-134 · v0.1.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026134,
  author    = {Fan, Yafu},
  title     = {Purchasing-Power-Parity Distortions, Multi-Currency Psychological Price Endings and the Southeast Asia–Taiwan–Japan Pricing Matrix},
  year      = {2026},
  publisher = {5D Library},
  edition   = {0.1.0},
  note      = {DOI pending}
}

本书其他章节结论