feat(859-3): 보이는 수 자릿수 규칙 한 쌍 — 줄 쌓기 화면 · 서버 계산서 글(셈 · 금액 그대로)

- 규칙 한 벌 = common_util_show_digits.ts ↔ master_doc_digits.py(짝 · 거울 시험 test_859_3)
  표 값 = 고른 줄의 원문 글자 자리(끝 0 살림 · 서버 표 캐시에 줄마다 `자리` 실음) ·
  식 값 = Q 3 · n 2 · cm 3(8-1 주①) › 원 단위 · 비목 이름 = 소수 한 자리 › 그 밖 유효숫자 3(소수 2~6) ·
  입력 · 요소 = 자료 그대로 · 만약으로 고른 기호 하나인 식은 그 값의 갈래를 따름
- 줄 쌓기 오른쪽(공식 줄 · 값 묶음 · 금액 줄 수량 · 단가 식 · 결과) · 왼쪽 값 · 작업량 줄 · M02 계산서 글
- test_845_2 기대 글 고침(노무비 계수 0.208333 → 0.208 — 뜻한 바뀜 · 금액 59,020.2 그대로)
- 관련 시험 + 관문 256 통과 · typecheck 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 21:55:48 +09:00
co-authored by Claude Opus 5.5
parent 47d2fe7192
commit aa36c4fb6b
14 changed files with 639 additions and 38 deletions
+3
View File
@@ -10,6 +10,7 @@
* 고르면 줄이 생김(닫으면 안 생김) · 있는 줄 = 자원 이름 단추
* ========================================================================== */
import type { PlacedTable } from "../common_util/common_util_show_digits";
import { createBadge } from "@ui/ui_template_badge";
import { createButton, createIconButton, setUiDiff } from "@ui/ui_template_button";
import { createRowMenu } from "@ui/ui_template_context_menu";
@@ -93,6 +94,8 @@ export interface EditHooks {
lists?: (given: Record<string, unknown>) => Record<string, unknown> | null;
/** 845-2 표 한 칸 읽기(캐시) — 「줄 따름」 값의 고른 줄 단위 */
look?: TableLook;
/** 859-3 캐시 표 통째 — 표 값의 원문 글자 자리(보이는 자리) */
tableCache?: (ref: string) => PlacedTable | undefined;
/** 846-2 그 기계 작업량 줄 */
work?: (machine: string) => WorkSpec[];
/** 848-3 ① 위 층 고침(SK 읽기 답 `위덮음` · M01 = 없음) */
+19 -13
View File
@@ -59,8 +59,9 @@ import {
} from "../common_util/common_util_line_stack_unit";
import { workAt } from "../common_util/common_util_line_stack_work";
import { workKey } from "../common_util/common_util_formula_doc_work";
import { showValue } from "../common_util/common_util_show_digits";
import { partName, partUnit } from "../common_util/common_util_machine_symbol_name";
import { katexNode, symTex, tex, txt, valTex, type TexCtx } from "./line_stack_tex";
import { katexNode, symTex, tex, txt, type TexCtx } from "./line_stack_tex";
import { lt } from "./line_stack_text";
import { workQty, workRows } from "./line_stack_work";
@@ -143,9 +144,14 @@ function rows(
const alias = tableAlias(doc); // 표 값 기호 화면 이름(요구 683)
const machine = doc.부품?.갈래 === "기계경비식"; // 845-2 한 줄 분수 한 층(중간 줄로 나눔)
const taken = new Set([...vars.keys(), ...lines.keys(), ...Object.values(alias)]);
/** 수 글 — 고르기 · 코드 값(S_ · 직종 1048 등)은 쉼표 없이 */
/** 수 글 — 고르기 · 코드 값(S_ · 직종 1048 등)은 쉼표 없이 · 그 밖 = 보이는 자리 규칙(859-3) */
const code = (id: string): boolean => /^S(_|$)/.test(id);
const numText = (id: string, v: number): string => (code(id) ? String(v) : eqText(v));
const numText = (id: string, v: unknown, u?: string): string => {
if (code(id)) return String(v);
return showValue(doc, id, v, vals, h.cache.tableOf, u);
};
/** 조판 값 글(천 자리 쉼표 = TeX 「{,}」) */
const show = (id: string, v: unknown): string => numText(id, v).replace(/,/g, "{,}");
/** 식 줄 「기호 = 기호식 = 값식 = 결과 단위」 — 같은 꼴이 이어지면 한 번만(만약이 수 하나를 탄 줄) */
const formula = (
id: string,
@@ -156,13 +162,13 @@ function rows(
more: Partial<TexCtx>,
): (string | HTMLElement)[] => {
const res = isNum(v)
? katexNode(`${code(id) ? String(v) : valTex(v)}\\ ${u ? txt(u) : ""}`) // 단위 글 = TeX 안전(「%」 주석 · 「^」 첨자 막음)
? katexNode(`${show(id, v)}\\ ${u ? txt(u) : ""}`) // 단위 글 = TeX 안전(「%」 주석 · 「^」 첨자 막음)
: typeof v === "string" // 글 값(기계 원문번호 등 · 838-3) = 그 글 · 기계면 이름
? el("span", { text: machineText(v, () => h.redraw?.()) ?? v })
: missing(a, id);
const sym = tex(n, { side: "sym", vals: vs, alias, ...more });
const val = tex(n, { side: "val", vals: vs, alias, ...more });
const same = isNum(v) && val === valTex(v);
const val = tex(n, { side: "val", vals: vs, alias, show, ...more });
const same = isNum(v) && val === show(id, v);
return [
katexNode(symTex(alias[id] ?? id)),
...(sym === val ? [] : [" = ", katexNode(sym)]),
@@ -342,7 +348,7 @@ function rows(
const glue = (...xs: (string | HTMLElement)[]): HTMLElement =>
el("span", { className: "lstk-pack", children: xs.filter((x) => x !== "") });
// 846-2 작업량 — 「시간당 작업량」 줄 먼저 · 수량 = 「÷ 시간당 작업량」
const wq = (): HTMLElement[] | null => workQty(doc, qty, w, scope, alias); // 줄마다 새 요소
const wq = (): HTMLElement[] | null => workQty(doc, qty, w, scope, alias, show); // 줄마다 새 요소
const byWork = wq() !== null;
const workHead = (): void => {
if (!w) return;
@@ -359,8 +365,8 @@ function rows(
glue(
" × ",
mu.wrap && qn
? katexNode(`\\left(${tex(qn, { side: "val", vals: scope, inline: true, cost, alias })}\\right)`) // prettier-ignore
: exprNode(qty, "val", scope, true, cost, { alias }),
? katexNode(`\\left(${tex(qn, { side: "val", vals: scope, inline: true, cost, alias, show })}\\right)`) // prettier-ignore
: exprNode(qty, "val", scope, true, cost, { alias, show }),
mu.qty ? ` ${mu.qty}` : "",
),
];
@@ -383,7 +389,7 @@ function rows(
const by = (line as { 비목곱?: Record<string, string> }).비목곱?.[c]; // 848-7 그 비목만 더 곱함
const byNode = by ? nodeOf(by) : null;
const times = byNode
? [glue(" × ", katexNode(`\\left(${tex(byNode, { side: "val", vals: scope, inline: true, cost: c, alias })}\\right)`))] // prettier-ignore
? [glue(" × ", katexNode(`\\left(${tex(byNode, { side: "val", vals: scope, inline: true, cost: c, alias, show })}\\right)`))] // prettier-ignore
: [];
push({
h: [`${COST_SHOW[c]} : `, glue(`${eqText(bundle[c])}${priceUnit}`), ...qtyNode(c), ...times, ` = ${one(part)} ${AMOUNT_UNIT}`], // prettier-ignore
@@ -399,9 +405,9 @@ function rows(
? [
exprNode(line.단가, "sym", scope, true, undefined, { place, alias }),
" = ",
exprNode(line.단가, "val", scope, true, undefined, { alias }),
exprNode(line.단가, "val", scope, true, undefined, { alias, show }),
]
: [glue(exprNode(line.단가, "val", scope, true, undefined, { alias }), priceUnit)];
: [glue(exprNode(line.단가, "val", scope, true, undefined, { alias, show }), priceUnit)];
const c = String(line.비목);
const bare = !!line.합밖 && !line.비목; // 합 밖 소계(810-2) = 글에만 금액 · 비목 칸 빈칸
workHead();
@@ -462,7 +468,7 @@ function rows(
push({
h: [
katexNode(symTex(doc.결과)),
` = ${isNum(r) ? `${eqText(r)} ${doc.결과단위 ?? ""}` : "—"}`,
` = ${isNum(r) ? `${numText(doc.결과, r, String(doc.결과단위 ?? ""))} ${doc.결과단위 ?? ""}` : "—"}`,
],
cls: "total",
});
+6 -1
View File
@@ -10,6 +10,7 @@
* 표 값(804-3) = [표 · 칸] 단추 → 표 고르기 창(`line_stack_pick.ts`) · 값 칸 누름 = 그 줄 · 칸(`pickCell`)
* ========================================================================== */
import { showValue } from "../common_util/common_util_show_digits";
import { createButton, createIconButton } from "@ui/ui_template_button";
import { eqText } from "@ui/ui_template_equation";
import { el, showToast } from "@ui/ui_template_elements";
@@ -162,7 +163,11 @@ export function buildBlock(
const v = vals[id];
const mach = machineText(v, () => h.change(() => undefined)); // 838-3 기계 원문번호 = 이름
if (mach) return mach;
if (isNum(v) || typeof v === "string") return `${eqText(v)} ${unitOf(id)}`.trim();
if (isNum(v)) {
const t = showValue(d, id, v, vals, h.tableCache); // 859-3 보이는 자리 규칙(표 = 원문 글자 자리)
return `${t} ${unitOf(id)}`.trim();
}
if (typeof v === "string") return `${eqText(v)} ${unitOf(id)}`.trim();
if (v && typeof v === "object") {
const key = vars.get(id)?.연결?.키; // 845-2 묶음 값 = 그 문서 결과 단위(원/시간 등)
const u = unitOf(id) || unitText(key ? h.subDoc(key)?.결과단위 : "");
+1
View File
@@ -444,6 +444,7 @@ export function createStackScreen(opt: StackScreenOptions) {
calc: calcSub,
lists: (g) => listsOf((q) => cache.links.element(q), g),
look: (p) => cache.links.table(p),
tableCache: (k) => cache.tableOf(k),
work: (m) => machineWork((q) => cache.links.element(q), m),
upper,
ctlEdit: !cp && edit(), // 848-3 M01 기초 = 시스템 관리자
+6 -2
View File
@@ -27,6 +27,8 @@ export interface TexCtx {
decided?: boolean;
/** 남은 분수 층(845-2 — 0 이면 안쪽 ÷ 는 한 줄 · 없음 = 끝없음) */
frac?: number;
/** 859-3 값 식의 기호 값 글(보이는 자리 규칙 · TeX 쉼표 「{,}」) — 없으면 `valTex` */
show?: (id: string, v: unknown) => string;
}
const HIDE = new Set(["반올림", "올림", "버림"]);
@@ -101,8 +103,10 @@ export function tex(n: Node, c: TexCtx): string {
const id = c.alias?.[n[1]] ?? n[1];
if (c.side === "sym") return symTex(id);
let v = c.vals[n[1]];
if (v && typeof v === "object" && c.cost) v = (v as Values)[c.cost];
return v === null || v === undefined || typeof v === "object" ? miss(symTex(id)) : valTex(v);
const part = !!v && typeof v === "object" && !!c.cost; // 묶음 값의 비목(단가 · 자료 그대로)
if (part) v = (v as Values)[c.cost!];
if (v === null || v === undefined || typeof v === "object") return miss(symTex(id));
return c.show && isNum(v) && !part ? c.show(n[1], v) : valTex(v);
}
case "field": {
const [, of, key] = n;
+22 -11
View File
@@ -11,8 +11,8 @@
import { createBadge } from "@ui/ui_template_badge";
import { el } from "@ui/ui_template_elements";
import { eqText } from "@ui/ui_template_equation";
import { varId, type FormulaDoc, type Node } from "../common_util/common_util_formula_doc";
import { showDigits, showValue } from "../common_util/common_util_show_digits";
import {
calcDoc,
isNum,
@@ -30,7 +30,7 @@ import {
restOfQty,
workUnit,
} from "../common_util/common_util_line_stack_work";
import { katexNode, symTex, tex, txt, valTex } from "./line_stack_tex";
import { katexNode, symTex, tex, txt } from "./line_stack_tex";
import { lt, type LsKey } from "./line_stack_text";
export interface WorkRow {
@@ -51,7 +51,15 @@ export function workTag(kind: string, title = ""): HTMLElement {
const chain = (...xs: string[]): (string | HTMLElement)[] =>
xs.flatMap((x, i) => (i ? [" = ", katexNode(x)] : [katexNode(x)]));
const unitTex = (u: string): string => (u ? `\\ ${txt(u)}` : "");
const amount = (v: unknown, u: string): string => `${valTex(v)}${unitTex(u)}`;
/** 859-3 시간당 작업량 Q = 소수 3 자리(건설 8-1 [주]① 계산값의 맺음) */
const workText = (v: unknown): string => showDigits(v, "식", "Q");
const workAmount = (v: unknown, u: string): string =>
`${workText(v).replace(/,/g, "{,}")}${unitTex(u)}`;
/** 859-3 문서 값 글(보이는 자리 규칙 · TeX 쉼표) */
const docShow =
(doc: FormulaDoc, vals: Values) =>
(id: string, v: unknown): string =>
showValue(doc, id, v, vals).replace(/,/g, "{,}");
/** 작업량 틀 풀이 — 값 줄 + 결과 식 줄(없으면 빈 목록) */
export function hourlyRows(
@@ -64,13 +72,15 @@ export function hourlyRows(
const vals = (a.값 ?? {}) as Values;
const vars = new Map((tpl.변수 ?? []).map((v) => [varId(v), v]));
const unit = (id: string): string => workUnit(shownUnitOf(vars.get(id), vals, look));
const pack = parts.uses.map((id) =>
katexNode(`${symTex(id)} = ${isNum(vals[id]) ? amount(vals[id], unit(id)) : txt("—")}`),
const show = docShow(tpl, vals);
const pack = parts.uses.map(
(id) =>
katexNode(`${symTex(id)} = ${isNum(vals[id]) ? `${show(id, vals[id])}${unitTex(unit(id))}` : txt("—")}`), // prettier-ignore
);
const res = vals[parts.id];
const sym = tex(parts.node, { side: "sym", vals, frac: 1 });
const val = tex(parts.node, { side: "val", vals, frac: 1 });
const end = isNum(res) ? amount(res, workUnit(tpl.결과단위)) : txt("—");
const val = tex(parts.node, { side: "val", vals, frac: 1, show });
const end = isNum(res) ? workAmount(res, workUnit(tpl.결과단위)) : txt("—");
return [
...(pack.length ? [{ h: pack, cls: "packs" }] : []),
{ h: chain(symTex(parts.id), sym, val, end), cls: "work" },
@@ -99,14 +109,14 @@ export function workRows(w: WorkInfo, c: WorkCtx): WorkRow[] {
c.miss();
}
const tag = workTag(w.꼴, tpl?.이름 ?? w.율);
if (!tpl) return [{ h: [tag, `${head} = `, isNum(w.값) ? `${eqText(w.값)} ${u}`.trim() : lt("Work_Wait")] }]; // prettier-ignore
if (!tpl) return [{ h: [tag, `${head} = `, isNum(w.값) ? `${workText(w.값)} ${u}`.trim() : lt("Work_Wait")] }]; // prettier-ignore
const a = calcDoc(tpl, c.links!, w.변수 ?? {}, [], new Map(), {});
const name = el("span", { className: "lstk-hint", text: tpl.이름 ?? w.율 });
return [{ h: [tag, name] }, ...hourlyRows(tpl, a, c.look)];
}
if (!isNum(w.값)) return [];
const tag = workTag(w.꼴 || "일당");
const res = amount(w.값, u);
const res = workAmount(w.값, u);
const parts = w.꼴 === "일당" ? dailyParts(w.율) : null;
if (parts) {
const val = (n: Node): string => tex(n, { side: "val", vals: c.vals, inline: true });
@@ -130,13 +140,14 @@ export function workQty(
w: WorkInfo | null,
scope: Values,
alias?: Record<string, string>,
show?: (id: string, v: unknown) => string,
): HTMLElement[] | null {
if (!w || !isNum(w.값) || w.값 <= 0) return null;
const got = restOfQty(doc, qty);
if (!got) return null;
const by = katexNode(`{}\\div ${amount(w.값, workUnit(w.단위))}`); // {} = 두 항 사이 ÷ 간격
const by = katexNode(`{}\\div ${workAmount(w.값, workUnit(w.단위))}`); // {} = 두 항 사이 ÷ 간격
if (!got.rest) return [by];
return [by, katexNode(`\\times ${tex(got.rest, { side: "val", vals: scope, inline: true, alias })}`)]; // prettier-ignore
return [by, katexNode(`\\times ${tex(got.rest, { side: "val", vals: scope, inline: true, alias, show: show ?? docShow(doc, scope) })}`)]; // prettier-ignore
}
const nameOf = (doc: FormulaDoc, id: string): string =>
@@ -44,6 +44,8 @@ export interface DocCache {
takeMissing: () => boolean;
/** 표 하나 넣음(고르기에서 받은 것) */
putTable: (ref: string, table: DocTable) => void;
/** 표 통째(859-3 보이는 자리 — 줄마다 원문 글자 자리 `자리`) · 없으면 undefined */
tableOf: (ref: string) => (DocTable & { 끊김?: string }) | undefined;
}
export function createDocCache(): DocCache {
@@ -99,5 +101,8 @@ export function createDocCache(): DocCache {
putTable(ref, table) {
tables.set(ref, table);
},
tableOf(ref) {
return tables.get(ref) ?? undefined;
},
};
}
+154
View File
@@ -0,0 +1,154 @@
/* =============================================================================
* common_util_show_digits.ts
* 보이는 수의 자릿수 규칙 한 벌(PLAN 859-3 · 856-5 · 요구 898 · 902) — 셈 값 · 저장 값 · 금액은 그대로 · 그리는 글자만
* ⚠ 짝 = resources/master_data/scripts/master_doc_digits.py(같은 규칙 · 한쪽을 고치면 다른 쪽도) ·
* 거울 시험 resources/tester/test_859_3_show_digits.py
* 갈래(`digitKind`) = 문서 식 줄 → 「식」 · 변수 연결 표 → 「표」 · 입력 · 선택 → 「입력」 · 그 밖(요소 · 단가산출) → 「요소」
* 규칙(자리 값은 `RULE` 한 곳):
* 표 = 고른 표 줄의 원문 글자 자리(끝 0 살림 — 건설 · 산림 1-2-2 1 [주]② 「항목에서 제시한 소수자리 우선」 ·
* 서버가 표 캐시에 줄마다 `자리` 를 실음) · 글자 자리를 모르면(끝 0 빠진 자료 · 사용자가 바꾼 값) 자료 수 그대로
* 식 = 기호 Q 3 · n 2 · cm 3 자리(건설 8-1 [주]① 계산값의 맺음) ›
* 단위가 원(원/…) · 비목 이름(노무비 · 재료비 · 경비)이면 소수 한 자리(1-2-2 2 「일위대가표의 금액란 0.1 원」 준용) ›
* 그 밖 = 유효숫자 3 · 소수 최소 2 · 최대 6(1-2-2 3 시공단위 품 표 근사 · 정수는 정수)
* 입력 · 요소 = 자료 수 그대로(소수 여섯 자리까지 · 끝 0 뗌 — `eqText`)
* 수 꼴 = 천 단위 쉼표 · 반올림(Intl — 짧은 10 진 글 기준 0.5 올림) · 화면 · fetch 없음
* ========================================================================== */
import { varId, type DocVar, type FormulaDoc } from "./common_util_formula_doc";
import { findRow, type DocTable } from "./common_util_formula_doc_table";
import { evalNode, tryParse, type Values } from "./common_util_formula_doc_view";
/** 자리 값 표 — 사용자 확정 값이 바뀌면 여기만 고침(짝 PY `RULE`) */
export const RULE = {
/** 입력 · 요소 · 자리 모르는 표 값 = 최대 자리(끝 0 뗌) */
plain: 6,
/** 건설 8-1 [주]① — 식이 낸 값 · 기호 그대로 */
symbol: { Q: 3, n: 2, cm: 3 } as Record<string, number>,
/** 원 단위 중간 값(율 줄 단가 · 원/… 식 값) */
money: 1,
/** 단위 없는 비목 값(기계 시간당 식) = 원 */
moneyNames: ["노무비", "재료비", "경비"],
/** 그 밖 식 값 — 유효숫자 · 소수 최소(정수는 정수) · 최대 */
sig: 3,
min: 2,
max: 6,
};
export type DigitKind = "식" | "표" | "입력" | "요소";
/** 서버 표 캐시 줄마다 원문 글자 자리(끝 0 있는 칸만) — `master_doc_record` 가 실음 */
export type PlacedTable = DocTable & { 자리?: (Record<string, number> | null)[] | null };
const formats = new Map<string, Intl.NumberFormat>();
/** 소수 `hi` 자리 반올림 · 끝 0 은 `lo` 자리까지 뗌 · 천 단위 쉼표 */
export function fmt(n: number, lo: number, hi: number): string {
const k = `${lo}:${hi}`;
let f = formats.get(k);
if (!f) {
f = new Intl.NumberFormat("ko-KR", { minimumFractionDigits: lo, maximumFractionDigits: hi });
formats.set(k, f);
}
return f.format(n);
}
/** 짧은 10 진 글의 [소수 자리, 맨 앞 자리 지수] — 0.0278 → [4, -2] */
function digits(n: number): [number, number] {
const [m, e] = Math.abs(n).toExponential().split("e");
const exp = Number(e);
const frac = (m.split(".")[1] ?? "").length;
return [Math.max(0, frac - exp), exp];
}
/** 표 값의 원문 글자 자리 — 지금 조건으로 고른 줄의 그 칸 · 값이 그 줄 값과 같을 때만(사용자가 바꾼 값 = undefined) */
export function tablePlaces(
v: DocVar | undefined,
value: unknown,
vals: Values,
tableOf?: (ref: string) => PlacedTable | null | undefined,
): number | undefined {
const k = v?.연결;
const ref = String(k?.표 ?? "");
const col = k?.칸;
if (!tableOf || !ref || !col || ref.includes("{")) return undefined;
const 조건: Record<string, unknown> = {};
for (const [c, t] of Object.entries(k?.조건 ?? {})) {
const n = tryParse(t);
if (n) 조건[c] = evalNode(n, vals);
}
try {
const t = tableOf(ref);
if (!t?.줄) return undefined;
const row = findRow(t, 조건, col);
if (typeof row[col] !== "number" || row[col] !== value) return undefined;
return t.자리?.[t.줄.indexOf(row)]?.[col] ?? undefined;
} catch {
return undefined;
}
}
/** 값 갈래 — 식 · 표 · 입력 · 요소 */
export function digitKind(doc: Pick<FormulaDoc, "식">, name: string, v?: DocVar): DigitKind {
if ((doc.식 ?? []).some((x) => String(x.기호 ?? "") === name)) return "식";
const kind = v?.연결?.갈래;
if (kind === "표") return "표";
if (kind === "입력" || kind === "선택") return "입력";
return v ? "요소" : "식";
}
/** 보이는 수 글 — `places` = 표 원문 글자 자리(모르면 없음) · 수가 아니면 글 그대로 */
export function showDigits(
value: unknown,
kind: DigitKind = "요소",
name = "",
unit = "",
places?: number,
): string {
if (value === null || value === undefined || value === "") return "";
if (typeof value !== "number" || !Number.isFinite(value)) return String(value);
const [own, exp] = digits(value);
if (kind === "표") {
const p = Math.max(places ?? 0, own);
return p <= RULE.plain ? fmt(value, p, p) : fmt(value, 0, RULE.plain);
}
if (kind !== "식") return fmt(value, 0, RULE.plain);
if (Object.prototype.hasOwnProperty.call(RULE.symbol, name))
return fmt(value, 0, RULE.symbol[name]);
if (unit.trim().startsWith("원") || RULE.moneyNames.includes(name))
return fmt(value, 0, RULE.money);
if (Number.isInteger(value)) return fmt(value, 0, 0);
const hi = Math.max(RULE.min, Math.min(RULE.max, RULE.sig - 1 - exp));
return fmt(value, RULE.min, hi);
}
/** 값이 온 기호 — 식 줄이 기호 하나(만약 = 지금 탄 갈래)면 그 기호로 따라감(K = 만약(K_입력 > 0, K_입력, K_2) → K_2) */
export function digitSource(doc: Pick<FormulaDoc, "식">, name: string, vals: Values): string {
const lines = new Map((doc.식 ?? []).map((x) => [String(x.기호 ?? ""), x.식]));
let at = name;
for (let hop = 0; hop < 8 && lines.has(at); hop++) {
let n = tryParse(lines.get(at));
while (n && n[0] === "call" && n[1] === "만약" && n[2].length === 3) {
const t = evalNode(n[2][0], vals);
if (t === undefined) return at;
n = n[2][t ? 1 : 2];
}
if (!n || n[0] !== "var" || n[1] === at) return at;
at = n[1];
}
return at;
}
/** 문서 기호 값 글 한 벌 — 값이 온 기호의 갈래 · 표 원문 글자 자리 · 단위(`unit` = 부르는 쪽이 정한 단위) */
export function showValue(
doc: Pick<FormulaDoc, "식" | "변수">,
name: string,
value: unknown,
vals: Values,
tableOf?: (ref: string) => PlacedTable | null | undefined,
unit?: string,
): string {
const src = digitSource(doc, name, vals);
const v = (doc.변수 ?? []).find((x) => varId(x) === src);
const kind = digitKind(doc, src, v);
const places = kind === "표" ? tablePlaces(v, value, vals, tableOf) : undefined;
return showDigits(value, kind, src, unit ?? String(v?.단위 ?? ""), places);
}
@@ -0,0 +1,185 @@
# -*- coding: utf-8 -*-
"""보이는 수의 자릿수 규칙 한 벌(PLAN 859-3 · 856-5 · 요구 898 · 902) —
셈 값 · 저장 값 · 금액은 그대로 · 그리는 글자만.
⚠ 짝 = `common_util/common_util_show_digits.ts`(같은 규칙 · 한쪽을 고치면 다른 쪽도) ·
거울 시험 `resources/tester/test_859_3_show_digits.py`.
갈래(`kind_of`) = 문서 식 줄 → 「식」 · 변수 연결 표 → 「표」 · 입력 · 선택 → 「입력」 ·
그 밖(요소 · 단가산출) → 「요소」.
규칙(자리 값은 `RULE` 한 곳):
표 = 고른 표 줄의 원문 글자 자리(끝 0 살림 —
건설 · 산림 1-2-2 1 [주]② 「항목에서 제시한 소수자리 우선」) ·
글자 자리를 모르면(끝 0 빠진 자료 · 사용자가 바꾼 값) 자료 수 그대로
식 = 기호 Q 3 · n 2 · cm 3 자리(건설 8-1 [주]① 계산값의 맺음) ›
단위가 원(원/…) · 비목 이름(노무비 · 재료비 · 경비)이면 소수 한 자리
(1-2-2 2 「일위대가표의 금액란 0.1 원」 준용) ›
그 밖 = 유효숫자 3 · 소수 최소 2 · 최대 6(1-2-2 3 시공단위 품 표 근사 · 정수는 정수)
입력 · 요소 = 자료 수 그대로(소수 여섯 자리까지 · 끝 0 뗌 — `eqText`)
수 꼴 = 천 단위 쉼표 · 반올림(0.5 올림 · 짧은 10 진 글 기준 — 화면 `Intl` 과 같음).
"""
from __future__ import annotations
from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
#: 자리 값 표 — 사용자 확정 값이 바뀌면 여기만 고침(짝 TS `RULE`)
RULE = {
"plain": 6, # 입력 · 요소 · 자리 모르는 표 값 = 최대 자리(끝 0 뗌)
"symbol": {"Q": 3, "n": 2, "cm": 3}, # 건설 8-1 [주]① — 식이 낸 값 · 기호 그대로
"money": 1, # 원 단위 중간 값(율 줄 단가 · 원/… 식 값)
"money_names": ("노무비", "재료비", "경비"), # 단위 없는 비목 값(기계 시간당 식) = 원
"sig": 3, # 그 밖 식 값 — 유효숫자
"min": 2, # 〃 소수 최소(정수는 정수)
"max": 6, # 〃 소수 최대
}
def dec(v) -> Decimal | None:
"""수 → Decimal(화면 double 의 짧은 10 진 글 · 글 · 참거짓 · 빈 값 = None)."""
if isinstance(v, bool) or v is None or isinstance(v, str):
return None
try:
d = Decimal(repr(float(v))) # 화면 수(double)와 같은 짧은 10 진 글
except (InvalidOperation, ValueError, TypeError, OverflowError):
return None
return d if d.is_finite() else None
def fmt(d: Decimal, lo: int, hi: int) -> str:
"""소수 `hi` 자리 반올림 · 끝 0 은 `lo` 자리까지 뗌 · 천 단위 쉼표
(Intl 과 같음 — 0 으로 반올림된 음수 = 「-0」)."""
q = d.quantize(Decimal(1).scaleb(-hi), ROUND_HALF_UP)
sign = "-" if q.is_signed() else ""
whole, _, frac = f"{abs(q):f}".partition(".")
frac = frac.rstrip("0")
frac += "0" * (lo - len(frac))
head = f"{int(whole):,}"
return f"{sign}{head}.{frac}" if frac else f"{sign}{head}"
def places_of(d: Decimal) -> int:
"""짧은 10 진 글의 소수 자리(0.10 → 1 · 3.0 → 0)."""
exp = d.normalize().as_tuple().exponent
return -exp if isinstance(exp, int) and exp < 0 else 0
def text_places(d: Decimal) -> int:
"""글자 그대로의 소수 자리(Decimal('0.10') → 2 · 표 파일 원문 글자)."""
exp = d.as_tuple().exponent
return -exp if isinstance(exp, int) and exp < 0 else 0
def row_places(row: dict) -> dict:
"""표 줄의 칸마다 원문 글자 자리 — 짧은 글보다 길 때만(끝 0 · 화면 캐시 `자리`)."""
out = {}
for col, v in row.items():
if isinstance(v, Decimal) and v.is_finite() and text_places(v) > places_of(v):
out[col] = text_places(v)
return out
def table_places(table: dict) -> list | None:
"""표 줄마다 `row_places`(끝 0 없는 줄 = None) · 표 통째 끝 0 없음 = None."""
got = [row_places(r) if isinstance(r, dict) else {} for r in table.get("줄") or []]
return [x or None for x in got] if any(got) else None
def table_value_places(link: dict, value, evaluate, get_table) -> int | None:
"""표 값의 원문 글자 자리 — 지금 조건으로 고른 줄(`find`)의 그 칸 글자 ·
값이 그 줄 값과 같을 때만(사용자가 바꾼 값 = None) ·
`evaluate(식 나무)` = 조건 값 · `get_table(키)` = 표(못 읽으면 None)."""
import master_doc as md
import master_doc_link as ml
ref, col = str(link.get("표") or ""), link.get("칸")
if not ref or not col or "{" in ref:
return None
conds = {}
for c, t in (link.get("조건") or {}).items():
try:
n = md.parse(t)
except md.DocError:
continue
conds[c] = evaluate(n)
try:
table = get_table(ref)
row = ml.find(table, conds, col) if table else None
except Exception: # noqa: BLE001 — 그림용 · 못 찾으면 자료 수 그대로
return None
if not row or dec(row.get(col)) is None or dec(row.get(col)) != dec(value):
return None
return row_places(row).get(col)
def kind_of(doc: dict, name: str, var: dict | None = None) -> str:
"""값 갈래 — 식 · 표 · 입력 · 요소."""
if any(str(x.get("기호") or "") == name for x in doc.get("식") or []):
return "식"
kind = ((var or {}).get("연결") or {}).get("갈래")
if kind == "표":
return "표"
if kind in ("입력", "선택"):
return "입력"
return "요소" if var is not None else "식"
def show(v, kind: str = "요소", name: str = "", unit: str = "", places: int | None = None) -> str:
"""보이는 수 글 — `places` = 표 원문 글자 자리(모르면 None) · 수가 아니면 글 그대로."""
if v is None or v == "":
return ""
if isinstance(v, bool):
return "true" if v else "false"
d = dec(v)
if d is None:
return str(v)
if kind == "표":
p = max(places or 0, places_of(d))
return fmt(d, p, p) if p <= RULE["plain"] else fmt(d, 0, RULE["plain"])
if kind != "식":
return fmt(d, 0, RULE["plain"])
if name in RULE["symbol"]:
return fmt(d, 0, RULE["symbol"][name])
if str(unit or "").strip().startswith("원") or name in RULE["money_names"]:
return fmt(d, 0, RULE["money"])
if d == d.to_integral_value():
return fmt(d, 0, 0)
hi = max(RULE["min"], min(RULE["max"], RULE["sig"] - 1 - d.adjusted()))
return fmt(d, RULE["min"], hi)
def source(doc: dict, name: str, evaluate) -> str:
"""값이 온 기호 — 식 줄이 기호 하나(만약 = 지금 탄 갈래)면 그 기호로 따라감 ·
`evaluate(식 나무)` = 그림용 값(모르면 None)."""
import master_doc as md
lines = {str(x.get("기호") or ""): x.get("식") for x in doc.get("식") or []}
at = name
for _ in range(8):
if at not in lines:
break
try:
n = md.parse(lines[at])
except md.DocError:
return at
while n and n[0] == "call" and n[1] == "만약" and len(n[2]) == 3:
t = evaluate(n[2][0])
if t is None:
return at
n = n[2][1 if t else 2]
if not n or n[0] != "var" or n[1] == at:
return at
at = n[1]
return at
def show_value(doc: dict, name: str, v, evaluate, get_table, unit: str | None = None) -> str:
"""문서 기호 값 글 한 벌(짝 TS `showValue`) — 값이 온 기호의 갈래 · 표 원문 글자 자리 · 단위."""
import master_doc as md
src = source(doc, name, evaluate)
var = next((x for x in doc.get("변수") or [] if md.var_id(x) == src), None)
kind = kind_of(doc, src, var)
places = None
if kind == "표" and var is not None:
places = table_value_places(var.get("연결") or {}, v, evaluate, get_table)
return show(v, kind, src, str((var or {}).get("단위") or "") if unit is None else unit, places)
@@ -5,15 +5,17 @@
브라우저가 같은 계산기(`common_util_formula_doc_calc.ts`)로 네트워크 없이 다시 셈.
화면 짝 = `common_util/common_util_formula_doc_cache.ts`(기록 → `DocLinks`).
- 요소 = 부른 꼴(payload) 그대로 + {값 | 빈 | 끊김}
- 표 = 표 통째(조건 · 값칸 · 줄) — 옵션 · 입력이 바뀌어도 화면이 줄을 찾음 · 표 아님 = {끊김}
- 표 = 표 통째(조건 · 값칸 · 줄) — 옵션 · 입력이 바뀌어도 화면이 줄을 찾음 · 표 아님 = {끊김} ·
줄마다 원문 글자 자리 `자리`(859-3)
- 단가산출 = 문서 통째(없으면 null)
`prefetch` = 식 · 옵션과 무관하게 글로 적힌 표 · 단가산출 키를 미리 담음(구멍 `{…}` 든 키는 셈 때만).
"""
from __future__ import annotations
import master_doc_calc as mc
import master_base as mf # 바탕 기반(색인 · 오류)
import master_doc_calc as mc
import master_doc_digits as mdd
class Rec:
@@ -52,6 +54,10 @@ class Rec:
return
keep = ("키", "원문번호", "이름", "조건", "범위규칙", "값칸", "줄")
self.표[ref] = {k: table[k] for k in keep if k in table}
if places := mdd.table_places(
table
): # 859-3 줄마다 원문 글자 자리(끝 0 · 화면이 수로 받으면 잃음)
self.표[ref]["자리"] = places
def table(self, p: dict):
self.see_table(str(p.get("표")))
@@ -9,7 +9,8 @@
`common_util/common_util_formula_doc_view.ts`(`offLine` — 선택으로 꺼진 줄).
금액 줄 = 「이름 : 단가 원/단위 × 수량 단위 = 금액 원」 · 묶음 줄 = 비목마다 「노무비 : …」 ·
계 = 「노무비 : 줄 + 줄 = 금액 원」 · 「합계 : 금액 원」.
수 꼴 = 화면과 같음 — 단가 · 수량 = `eqText`(소수 여섯 자리까지 · 셈 값 그대로) ·
수 꼴 = 화면과 같음 — 단가 · 수량 = 보이는 자리 규칙(859-3 · `master_doc_digits` ·
짝 `common_util_show_digits.ts`) ·
줄 금액 = 소수 한 자리 · 비목 · 합계 = 원(셈 답의 끝수 그대로 · 여기서 자르지 않음).
옮기지 않은 것(화면만) — 식 조판(KaTeX · 수량 식은 값 하나로) · 공식 줄 · 펼침 ·
작업량 줄(846-2) · 굳은 기계 이름(847-1) · 비목곱 인수 글(848-7 · 금액은 답 그대로) ·
@@ -23,6 +24,7 @@ from decimal import ROUND_FLOOR, ROUND_HALF_UP, Decimal, InvalidOperation
import master_doc as md
import master_doc_calc as mc
import master_doc_digits as mdd
COSTS = md.COSTS # 노무비 · 재료비 · 경비
COST_SHOW = {"노무비": "노무비", "재료비": "재료비", "경비": "경 비"}
@@ -211,6 +213,24 @@ def _num(v) -> Decimal | None:
return _dec(v)
def _table_of(links):
"""연결의 마스터 표 읽기(`Links.master` · 기록 `Rec.links.master`) — 없으면 None."""
master = getattr(links, "master", None) or getattr(
getattr(links, "links", None), "master", None
)
return master.get if master is not None else (lambda ref: None)
def shown(doc: dict, node, v, look: "_Look", links, money: bool = False) -> str:
"""금액 줄 단가 · 수량 값 글(859-3) — 기호 하나 = 그 변수 갈래 규칙(표 = 원문 글자 자리) ·
상수 = 자료 그대로 · 식 = 식 규칙(`money` = 단가 = 원 단위)."""
if node and node[0] == "var":
return mdd.show_value(doc, node[1], v, look.value, _table_of(links))
if node and node[0] == "num":
return mdd.show(v)
return mdd.show(v, "식", "", "원" if money else "")
def _u(text: str, unit: str) -> str:
return f"{text} {unit}" if unit else text
@@ -236,6 +256,7 @@ def money_lines(doc: dict, answer: dict, links) -> list[dict]:
sub = None
mu = money_units(line, node_of(line.get("단가")), node_of(line.get("수량")), pv, sub)
qty = got.get("수량")
qty_text = shown(doc, node_of(line.get("수량")), qty, look, links)
base = {
"i": i,
"이름": name,
@@ -244,8 +265,9 @@ def money_lines(doc: dict, answer: dict, links) -> list[dict]:
"꺼짐": look.off_line(line),
"합밖": bool(got.get("합밖")),
"묶음": line.get("묶음") or "",
"수량글": qty_text,
}
tail = "" if qty is None else " × " + _u(eq_text(qty), mu["qty"])
tail = "" if qty is None else " × " + _u(qty_text, mu["qty"])
if got.get("까닭") and got.get("금액") is None:
why = got["까닭"]
out.append({**base, "비목": line.get("비목"), "단가": None, "금액": None, "까닭": why,
@@ -260,12 +282,14 @@ def money_lines(doc: dict, answer: dict, links) -> list[dict]:
price = _u(eq_text(bundle.get(c)), mu["price"])
text = f"{COST_SHOW[c]} : {price}{tail} = {one(part)} {AMOUNT_UNIT}"
out.append({**base, "비목": c, "묶음줄": True, "단가": _num(bundle.get(c)),
"단가글": eq_text(bundle.get(c)),
"금액": _num(part), "글": text}) # fmt: skip
continue
amt, price = got.get("금액"), got.get("단가")
text = f"{name} : {_u(eq_text(price), mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}"
out.append({**base, "비목": line.get("비목"), "단가": _num(price), "금액": _num(amt),
"글": text}) # fmt: skip
price_text = shown(doc, node_of(line.get("단가")), price, look, links, money=True)
text = f"{name} : {_u(price_text, mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}"
out.append({**base, "비목": line.get("비목"), "단가": _num(price), "단가글": price_text,
"금액": _num(amt), "글": text}) # fmt: skip
return out
@@ -307,8 +331,8 @@ def sheet_groups(doc: dict, answer: dict, links) -> list[dict]:
if x.get("까닭"):
text = f"— {x['까닭']}"
else:
price = "—" if x["단가"] is None else _u(eq_text(x["단가"]), mu["price"])
qty = "" if x["수량"] is None else " * " + _u(eq_text(x["수량"]), mu["qty"])
price = "—" if x["단가"] is None else _u(x["단가글"], mu["price"])
qty = "" if x["수량"] is None else " * " + _u(x["수량글"], mu["qty"])
text = f"{price}{qty} = {one(x['금액'] or 0)}"
groups[c].append(
{
@@ -0,0 +1,35 @@
/* 859-3 거울 헬퍼 — 보이는 자리 규칙(TS `common_util_show_digits.ts`)을 Node 로 돌림(`master_doc_digits.py` 짝).
* stdin = {수: [[값, 갈래, 이름, 단위, 자리|null]], 갈래: [{문서: {식}, 이름, 변수}], 표: {키: 표}, 자리: [{변수, 값, 값들}],
* 문서값: [{문서: {식, 변수}, 값들, 기호: [[이름, 값]]}]}
* stdout = {수: [showDigits], 갈래: [digitKind], 자리: [tablePlaces | null], 문서값: [[showValue]]} */
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
const cache = new Map();
function load(at) {
if (cache.has(at)) return cache.get(at);
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText;
const box = { exports: {} };
cache.set(at, box.exports);
const need = (p) => (p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p));
new Function("exports", "module", "require", js)(box.exports, box, need);
return box.exports;
}
const dig = load(path.join(__dirname, "..", "..", "common_util", "common_util_show_digits.ts"));
const input = JSON.parse(fs.readFileSync(0, "utf8"));
const tables = input.표 || {};
const res = {
수: (input.수 || []).map(([v, k, n, u, p]) => dig.showDigits(v, k, n, u, p ?? undefined)),
갈래: (input.갈래 || []).map((x) => dig.digitKind(x.문서, x.이름, x.변수 ?? undefined)),
문서값: (input.문서값 || []).map((x) =>
x.기호.map(([n, v]) => dig.showValue(x.문서, n, v, x.값들, (k) => tables[k])),
),
자리: (input.자리 || []).map(
(x) => dig.tablePlaces(x.변수, x.값, x.값들, (k) => tables[k]) ?? null,
),
};
process.stdout.write(JSON.stringify(res));
+3 -2
View File
@@ -86,7 +86,8 @@ def test_GC000088_비목_줄_단위_자리(world):
"⟦\\text{휴지율}⟧ = ⟦\\dfrac{\\text{월간급여지급일}}{\\text{월간가동일수}}⟧ = ⟦\\dfrac{25}{20}⟧"
in sub
)
assert "\\dfrac{1}{8} \\times 1.333333 \\times 1.25⟧ = ⟦0.208333" in sub
# 859-3 식이 낸 값 = 유효숫자 3(그림만 · 금액 59,020.2 그대로)
assert "\\dfrac{1}{8} \\times 1.33 \\times 1.25⟧ = ⟦0.208\\ " in sub
assert (
"\\text{노무비 계수}⟧ = ⟦\\dfrac{\\text{일}}{\\text{일일근무시간}} \\times \\text{상여율} \\times \\text{휴지율}⟧"
in sub
@@ -97,7 +98,7 @@ def test_GC000088_비목_줄_단위_자리(world):
assert "⟦\\text{가격}⟧ = 142,069 천원" in sub
assert "⟦\\text{직종}⟧ = 1048" in sub # 코드 값 = 쉼표 없음
assert (
"조종원 : ⟦283{,}297⟧ 원/인 × ⟦\\left(1 \\times 0.208333\\right)⟧ 인 = 59,020.2 원" in sub
"조종원 : ⟦283{,}297⟧ 원/인 × ⟦\\left(1 \\times 0.208\\right)⟧ 인 = 59,020.2 원" in sub
)
assert "⟦\\text{가산}⟧ = ⟦0\\ \\text{\\%}⟧" in sub # % = TeX 글(주석으로 안 먹힘)
+161
View File
@@ -0,0 +1,161 @@
"""859-3 지킴 — 보이는 수 자릿수 규칙 한 쌍
(TS `common_util_show_digits.ts` ↔ PY `master_doc_digits.py`).
① 거울 — 같은 값 · 갈래 · 기호 · 단위 · 표 자리 → 같은 글(헬퍼 `helper_859_3_show_digits.cjs`) ·
갈래 판정 · 표 값 원문 글자 자리(서버 표 캐시 `자리` → 화면 `tablePlaces`) · 문서 기호 값 글 —
M01 수식 문서 전부(기본 입력 셈 답).
② 규칙 결과 — 표 값 끝 0 살림 · 식 품 유효숫자 3 · 원 단위 소수 한 자리 · 8-1 Q 3 자리 ·
입력 · 요소 그대로.
③ 그림만 — 서버 산출근거 글의 금액은 셈 답 그대로(글 끝 「= 금액」 = 줄 금액 소수 한 자리).
"""
from __future__ import annotations
import importlib
import json
import os
import subprocess
from decimal import Decimal
from functools import lru_cache
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Logic_Standard as st
mc = importlib.import_module("master_doc_calc")
md = importlib.import_module("master_doc")
mdd = importlib.import_module("master_doc_digits")
mdt = importlib.import_module("master_doc_text")
rec = importlib.import_module("master_doc_record")
HERE = os.path.dirname(os.path.abspath(__file__))
NUMS = [0, 1, -1, 8, 250, 0.5, 1.5, 2.5, -2.5, 0.05, 0.15, 0.25, 0.35, 1.05, 1.005, 2.675, 99.95,
-0.05, 0.1 + 0.2, 1e-7, 0.0004, 0.000417, 0.027778, 0.0285, 0.0995, 0.99999, 1.4552,
0.606061, 33971.813333, 535.396667, 12987.917773, 2446.08, 1234567.891234567,
59018.0857142857, 284.42142857142, 123456789012.345, 26890.75, 1502.04999,
0.1, 3.0] # fmt: skip
KINDS = [("식", "", ""), ("식", "Q", ""), ("식", "n", ""), ("식", "cm", ""), ("식", "", "원/시간"),
("식", "", "인"), ("표", "", ""), ("입력", "", ""), ("요소", "", "원/인")] # fmt: skip
def _js(v):
if isinstance(v, Decimal):
return float(v)
if isinstance(v, dict):
return {k: _js(x) for k, x in v.items()}
if isinstance(v, (list, tuple)):
return [_js(x) for x in v]
if isinstance(v, (mc.Blank, mc.Stop)):
return None
return v
@lru_cache(maxsize=1)
def world():
whole = m01.loaded()[1]
docs = m01_doc.docs()
links = st._links(whole)
answers = {k: mc.calc(d, links, None) for k, d in docs.items() if d.get("금액")}
return docs, links, answers
def _helper(payload: dict) -> dict:
run = subprocess.run(
["node", os.path.join(HERE, "helper_859_3_show_digits.cjs")],
input=json.dumps(payload, ensure_ascii=False),
capture_output=True,
text=True,
encoding="utf-8",
check=True,
)
return json.loads(run.stdout)
@lru_cache(maxsize=1)
def mirror():
docs, links, answers = world()
nums = [[v, k, n, u, p] for v in NUMS for k, n, u in KINDS for p in (None, 2, 3)]
kinds, places, tables, py = [], [], {}, {"수": [], "갈래": [], "자리": [], "문서값": []}
whole = []
keep = rec.Rec(links)
for key, a in answers.items():
doc = docs[key]
vals = a.get("값") or {}
look = mdt._Look(doc, a, links)
shown = {k: _js(v) for k, v in vals.items() if v is not None}
names = [md.var_id(x) for x in doc.get("변수") or []]
names += [str(x.get("기호") or "") for x in doc.get("식") or []]
pairs = [[n, float(vals[n])] for n in names if isinstance(vals.get(n), Decimal)]
get = links.master.get
py["문서값"].append([mdd.show_value(doc, n, vals[n], look.value, get) for n, _ in pairs])
part = {"식": doc.get("식") or [], "변수": _js(doc.get("변수") or [])}
whole.append({"문서": part, "값들": shown, "기호": pairs})
for var in doc.get("변수") or []:
name = md.var_id(var)
kinds.append({"문서": {"식": doc.get("식") or []}, "이름": name, "변수": _js(var)})
py["갈래"].append(mdd.kind_of(doc, name, var))
v = vals.get(name)
link = var.get("연결") or {}
if link.get("갈래") != "표" or not isinstance(v, Decimal):
continue
ref = str(link.get("표") or "")
keep.see_table(ref)
tables[ref] = _js(keep.표[ref])
places.append({"변수": _js(var), "값": float(v), "값들": shown})
py["자리"].append(mdd.table_value_places(link, v, look.value, links.master.get))
nums.append([float(v), "표", name, "", py["자리"][-1]])
for v, k, n, u, p in nums:
py["수"].append(mdd.show(v, k, n, u, p))
every = [v for d in docs.values() for v in d.get("변수") or []]
refs = {str((v.get("연결") or {}).get("표") or "") for v in every}
for ref in refs:
if ref and "{" not in ref and ref not in tables:
keep.see_table(ref)
tables[ref] = _js(keep.표[ref])
ts = _helper({"수": nums, "갈래": kinds, "표": tables, "자리": places, "문서값": whole})
return nums, py, ts
def test_수_꼴_거울():
nums, py, ts = mirror()
assert len(nums) > 7000
bad = [(n, a, b) for n, a, b in zip(nums, py["수"], ts["수"]) if a != b]
assert not bad, bad[:10]
def test_갈래_표_자리_거울():
_, py, ts = mirror()
assert len(py["갈래"]) > 10000 and py["갈래"] == ts["갈래"]
assert len(py["자리"]) > 7000 and py["자리"] == ts["자리"]
assert sum(1 for p in py["자리"] if p) > 500 # 끝 0 글자 자리가 실제로 실려 감
def test_문서_기호_값_글_거울():
_, py, ts = mirror()
assert sum(map(len, py["문서값"])) > 15000
bad = [(a, b) for x, y in zip(py["문서값"], ts["문서값"]) for a, b in zip(x, y) if a != b]
assert not bad and py["문서값"] == ts["문서값"], bad[:10]
def test_규칙_결과():
show = mdd.show
assert show(0.1, "표", "Q_수량^표", "인", 2) == "0.10" # 원문 글자 끝 0
assert show(0.1, "표") == "0.1" and show(3.0, "표", "", "", 1) == "3.0"
assert show(0.027778, "식", "Q_보링공", "인") == "0.0278" # 유효숫자 3
assert show(1.4552, "식") == "1.46" and show(8, "식") == "8"
assert show(33971.813333, "식", "", "원") == "33,971.8" # 원 단위 한 자리
assert show(70.12345, "식", "Q") == "70.123" and show(2.456, "식", "n") == "2.46"
assert show(0.027778, "입력") == "0.027778" and show(1846.39, "요소") == "1,846.39"
assert show("5401-0017") == "5401-0017" and show(None) == "" and show(1048, "입력") == "1,048"
def test_서버_글_금액_그대로():
docs, links, answers = world()
for key in ("GF000220", "GC000994", "GC000996"):
for line in mdt.money_lines(docs[key], answers[key], links):
if line.get("금액") is not None:
assert line["글"].endswith(f"= {mdt.one(line['금액'])} 원")
got = {x["이름"]: x for x in mdt.money_lines(docs["GC000994"], answers["GC000994"], links)}
assert got["보링공"]["수량글"] == "0.0278"
rate = [x for x in mdt.money_lines(docs["GC000996"], answers["GC000996"], links)]
assert any(x.get("단가글") == "33,971.8" for x in rate)