/watosar/KatexPhysics - Scrapbox Reader

generated at 2/16/2025, 5:36:59 PM
KatexPhysics
from : GitHub - balthild/katex-physics: Implemented some commands in LaTeX physics package for KaTeX
もともとのマクロ定義をコピペして利用できた。
ket, bra, braketはkatexもともとのマクロが使いたいので消している

preview: 

macros.jsfunction popNextArg(ctx) {
  return ctx.consumeArgs(1)[0].reverse().map(t => t.text).join("");
}

function getSqureParameter(ctx) {
  while (ctx.future().text === " ") {
      ctx.popToken();
  }

  let parameter = "";
  if (ctx.future().text === "[") {
      ctx.popToken();
      while (true) {
          const ch = ctx.popToken().text;

          if (ch === "]") {
              break;
          } else if (ch === "EOF") {
              throw new Error("Expecting ]");
          }

          parameter += ch;
      }
  }

  return parameter;
}

function isAlt(ctx) {
  while (ctx.future().text === " ") {
      ctx.popToken();
  }

  if (ctx.future().text === "*") {
      ctx.popToken();
      return true;
  }

  return false;
}


const braces = {
  "(": ")",
  "[": "]",
  "{": "}",
  "\\{": "\\}",
  "|": "|",
};

const evalBraces = {
  "(": "|",
  "[": "|",
  "{": "}",
};


const matrixBraces = {
  "(": ")",
  "[": "]",
  "{": "}",
  "\\{": "\\}",
  "|": "|"
};

const isDigit = /^\d+$/;
const dd = (n, f) => "\\dd[" + n + "]{" + f + "}";
const pd = (n, f) => "\\pd[" + n + "]{" + f + "}";

export const macros = {
    "\\qty"(ctx) {
      const start = ctx.popToken().text;
      const end = braces[start];
      if (typeof end === "undefined") {
          throw new Error("Expecting opening delimeters after \\qty");
      }

      let expr = ["\\left"];
      expr.push(start === "{" ? "\\{" : start);

      let opened = 0;
      while (true) {
          const next = ctx.popToken().text;
          if (next === "EOF") {
              throw new Error("Expecting closing delimeters " + end + " after \\mqty");
          } else if (next !== end) {
              expr.push(next);
              if (next === start) {
                  ++opened;
              }
          } else if (opened > 0) {
              expr.push(next);
              --opened;
          } else {
              // end
              expr.push("\\right");
              expr.push(end === "}" ? "\\}" : next);
              break;
          }
      }

      return expr.join(" ");
    },
    "\\abs": "\\qty|{#1}|",
    "\\eval"(ctx) {
        const start = ctx.popToken().text;
        let end = evalBraces[start];
        if (typeof end === "undefined") {
            throw new Error("Expecting opening delimeters after \\eval");
        }

        let expr = ["\\left"];
        expr.push(start === "{" ? "." : start);

        let opened = 0;
        while (true) {
            const next = ctx.popToken().text;
            if (next === "EOF") {
                throw new Error("Expecting " + end + " after \\eval");
            } else if (next !== end) {
                expr.push(next);
                if (next === start) {
                    ++opened;
                }
            } else if (end === "}" && opened > 0) {
                expr.push(next);
                --opened;
            } else {
                // end
                expr.push("\\rule{0px}{1.2em}\\right|");
                break;
            }
        }

        return expr.join(" ");
    },
    "\\dd"(ctx) {
      const n = getSqureParameter(ctx);

      let op = "\\mathrm{d}";
      if (n && !isDigit.test(n) || n > 1) {
          op += "^{" + n + "}";
      }

      if (ctx.future().text !== "{") {
          return op;
      }

      try {
          const ch = popNextArg(ctx);
          return "\\mathop{}\\!" + op + "{" + ch + "}";
      } catch (e) {
          return op;
      }
    },
    "\\pd"(ctx) {
        const n = getSqureParameter(ctx);

        let op = "\\partial";
        if (n && !isDigit.test(n) || n > 1) {
            op += "^{" + n + "}";
        }

        if (ctx.future().text !== "{") {
            return op;
        }

        try {
            const ch = popNextArg(ctx);
            return "\\mathop{}\\!" + op + "{" + ch + "}";
        } catch (e) {
            return op;
        }
    },
    "\\dv"(ctx) {
        const n = getSqureParameter(ctx);
        const fn = popNextArg(ctx);

        while (ctx.future().text === " ") {
            ctx.popToken();
        }
        if (ctx.future().text !== "{") {
            return "\\frac{\\dd^{" + n + "}}{" + dd(1, fn) + "^{" + n + "}}";
        }

        let variable;
        try {
            variable = popNextArg(ctx);
        } catch (e) {}

        return "\\frac{" + dd(n, fn) + "}{" + dd(1, variable) + "^{" + n + "}}";
    },
    "\\pdv"(ctx) {
        const n = getSqureParameter(ctx);
        const fn = popNextArg(ctx);
        if (n) {
            while (ctx.future().text === " ") {
                ctx.popToken();
            }
            if (ctx.future().text !== "{") {
                return "\\frac{\\pd^{" + n + "}}{" + pd(1, fn) + "^{" + n + "}}";
            }
            let variable;
            try {
                variable = popNextArg(ctx);
            } catch (e) {}
            return "\\frac{" + pd(n, fn) + "}{" + pd(1, variable) + "^{" + n + "}}";
        }
        const args = [];
        while (true) {
            while (ctx.future().text === " ") {
                ctx.popToken();
            }
            if (ctx.future().text !== "{") {
                break;
            }
            try {
                args.push(popNextArg(ctx));
            } catch (e) {
                break;
            }
        }
        if (args.length === 0) {
            return "\\frac{\\partial}{" + pd(args.length, fn) + "}"
        }

        return "\\frac{" + pd(args.length, fn) + "}{" +
            args.map(arg => pd(1, arg)).join("") + "}"
    },
    "\\ketbra"(ctx) {
        const a = popNextArg(ctx);
  
        let expr = ["\\left|{" + a + "}\\middle>\\middle<{"];
  
        try {
            expr.push(popNextArg(ctx));
        } catch (e) {
            expr.push(a);
        }
  
        expr.push("}\\right|");
        return expr.join(" ");
    },
    "\\expval"(ctx) {
          const a = popNextArg(ctx);
  
          while (ctx.future().text === " ") {
              ctx.popToken();
          }
          if (ctx.future().text !== "{") {
              return "\\left<{" + a + "}\\right>";
          }
  
          const b = popNextArg(ctx);
          return "\\left<{" + b + "}\\middle|{" + a + "}\\middle|{" + b + "}\\right>";
    },
    "\\matrixel"(ctx) {
          const [a, b, c] = ctx.consumeArgs(3).map(arg => arg.reverse().map(t => t.text).join(""));
  
          return "\\left<{" + a + "}\\middle|{" + b + "}\\middle|{" + c + "}\\right>";
    },
    "\\mqty"(ctx) {
        const start = ctx.popToken().text;
        const end = matrixBraces[start];
        if (typeof end === "undefined") {
            throw new Error("Expecting opening delimeters after \\qty");
        }
  
        let expr = ["\\left"];
        expr.push(start === "{" ? "\\{" : start);
        expr.push("\\begin{matrix}");
  
        let opened = 0;
        while (true) {
            const next = ctx.popToken().text;
            if (next === "EOF") {
                throw new Error("Expecting closing delimeters " + end + " after \\mqty");
            } else if (next !== end) {
                expr.push(next);
                if (next === start) {
                    ++opened;
                }
            } else if (opened > 0) {
                expr.push(next);
                --opened;
            } else {
                // end
                expr.push("\\end{matrix}\\right");
                expr.push(end === "}" ? "\\}" : next);
                break;
            }
        }
  
        return expr.join(" ");
    },
    "\\mdet": "\\left|\\begin{matrix}#1\\end{matrix}\\right|",
    "\\dmat"(ctx) {
        const fill = getSqureParameter(ctx);
        const elements = popNextArg(ctx).split(",");
        const lines = [];
  
        for (let i = 0; i < elements.length; ++i) {
            let line = new Array(elements.length).fill(fill);
            line[i] = elements[i];
            lines.push(line.map(el => "{" + el + "}").join("&"));
        }
  
        return lines.join("\\\\");
    },
    "\\admat"(ctx) {
        const fill = getSqureParameter(ctx);
        const elements = popNextArg(ctx).split(",");
        const lines = [];
  
        for (let i = 0; i < elements.length; ++i) {
            let line = new Array(elements.length).fill(fill);
            line[elements.length - i - 1] = elements[i];
            lines.push(line.map(el => "{" + el + "}").join("&"));
        }
  
        return lines.join("\\\\");
    },
    "\\imat"(ctx) {
        const n = parseInt(popNextArg(ctx));
        if (isNaN(n)) {
            throw new Error("Expecting integers as the parameter of \\imat");
        }
        return "\\dmat[0]{" + new Array(n).fill(1).join(",") + "}";
    },
    "\\xmat"(ctx) {
        const labeled = isAlt(ctx);
        const [x, n, m] = [
            popNextArg(ctx),
            parseInt(popNextArg(ctx)),
            parseInt(popNextArg(ctx)),
        ];

        if (isNaN(n) || isNaN(m)) {
            throw new Error("Expecting integers as the second and third parameter of \\xmat");
        }

        if (!labeled || (n === 1 && m === 1)) {
            return new Array(n).fill(new Array(m).fill(x).join("&")).join("\\\\");
        }

        const matrix = [];
        for (let i = 1; i <= n; ++i) {
            const row = [];
            for (let j = 1; j <= m; ++j) {
                let label = "" + (n > 1 ? i : "") + (m > 1 ? j : "");
                row.push(x + "_{" + label + "}")
            }
            matrix.push(row);
        }

        return matrix.map(row => row.join(",")).join("\\\\")
    },
    "\\qc": ",\\quad",
    "\\qq": ctx => (isAlt(ctx) ? "" : "\\quad") + "\\text{" + popNextArg() + "}\\quad",
    "\\qcc": ctx => (isAlt(ctx) ? "" : "\\quad") + "\\text{c.c.}\\quad",
    "\\qif": ctx => (isAlt(ctx) ? "" : "\\quad") + "\\text{if}\\quad",
}