feat: add support for additional derivative notations including Newton's dot and Lagrange prime notations

Author: arnog

CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+### Features
+
+- **([#163](https://github.com/cortex-js/compute-engine/issues/163)) Additional
+  Derivative Notations**: Added support for parsing multiple derivative notations
+  beyond Leibniz notation:
+
+  - **Newton's dot notation** for time derivatives: `\dot{x}` → `["D", "x", "t"]`,
+    `\ddot{x}` for second derivative, `\dddot{x}` and `\ddddot{x}` for higher orders.
+    The time variable is configurable via the new `timeDerivativeVariable` parser
+    option (default: `"t"`).
+
+  - **Lagrange prime notation with arguments**: `f'(x)` now parses to
+    `["D", ["f", "x"], "x"]`, inferring the differentiation variable from the
+    function argument. Works for `f''(x)`, `f'''(x)`, etc. for higher derivatives.
+
+  - **Euler's subscript notation**: `D_x f` → `["D", "f", "x"]` and
+    `D^2_x f` or `D_x^2 f` for second derivatives.
+
 ### Bug Fixes
 
 - **Matrix Operations Type Validation**: Fixed matrix operations (`Shape`, `Rank`,

src/compute-engine/index.ts

@@ -1947,6 +1947,7 @@ export class ComputeEngine implements IComputeEngine {
       parseUnexpectedToken: (_lhs, _parser) => null,
       preserveLatex: false,
       quantifierScope: 'tight',
+      timeDerivativeVariable: 't',
     };
 
     const result = parse(

src/compute-engine/latex-syntax/dictionary/definitions-core.ts

@@ -909,7 +909,7 @@ export const DEFINITIONS_CORE: LatexDictionary = [
     // @todo: Leibniz notation: {% latex " \\frac{d^n}{dx^n} f(x)" %}
     // @todo: Euler modified notation: This notation is used by Mathematica. The Euler notation uses `D` instead of
     // `\partial`: `\partial_{x} f`,  `\partial_{x,y} f`
-    // @todo: Newton notation: `\dot{v}` -> first derivative relative to time t `\ddot{v}` -> second derivative relative to time t
+    // Newton notation (\dot{v}, \ddot{v}) is implemented below
 
     serialize: (serializer: Serializer, expr: Expression): string => {
       const degree = machineValue(operand(expr, 2)) ?? 1;
@@ -921,6 +921,100 @@ export const DEFINITIONS_CORE: LatexDictionary = [
       return base + '^{(' + serializer.serialize(operand(expr, 2)) + ')}';
     },
   },
+
+  // Newton notation for time derivatives: \dot{x}, \ddot{x}, etc.
+  {
+    name: 'NewtonDerivative1',
+    latexTrigger: ['\\dot'],
+    kind: 'prefix',
+    precedence: 740,
+    parse: (parser: Parser): Expression | null => {
+      const body = parser.parseGroup();
+      if (body === null) return null;
+      const t = parser.options.timeDerivativeVariable;
+      return ['D', body, t] as Expression;
+    },
+  },
+  {
+    name: 'NewtonDerivative2',
+    latexTrigger: ['\\ddot'],
+    kind: 'prefix',
+    precedence: 740,
+    parse: (parser: Parser): Expression | null => {
+      const body = parser.parseGroup();
+      if (body === null) return null;
+      const t = parser.options.timeDerivativeVariable;
+      return ['D', ['D', body, t], t] as Expression;
+    },
+  },
+  {
+    name: 'NewtonDerivative3',
+    latexTrigger: ['\\dddot'],
+    kind: 'prefix',
+    precedence: 740,
+    parse: (parser: Parser): Expression | null => {
+      const body = parser.parseGroup();
+      if (body === null) return null;
+      const t = parser.options.timeDerivativeVariable;
+      return ['D', ['D', ['D', body, t], t], t] as Expression;
+    },
+  },
+  {
+    name: 'NewtonDerivative4',
+    latexTrigger: ['\\ddddot'],
+    kind: 'prefix',
+    precedence: 740,
+    parse: (parser: Parser): Expression | null => {
+      const body = parser.parseGroup();
+      if (body === null) return null;
+      const t = parser.options.timeDerivativeVariable;
+      return ['D', ['D', ['D', ['D', body, t], t], t], t] as Expression;
+    },
+  },
+
+  // Euler notation for derivatives: D_x f, D^2_x f, D_x^2 f
+  // Uses latexTrigger to intercept before symbol parsing combines D with subscript
+  {
+    name: 'EulerDerivative',
+    latexTrigger: ['D'],
+    kind: 'expression',
+    parse: (parser: Parser): Expression | null => {
+      let degree = 1;
+      let variable: Expression | null = null;
+
+      // Parse subscript and superscript in either order (D_x^2 or D^2_x)
+      let done = false;
+      while (!done) {
+        if (parser.match('_')) {
+          // Parse the subscript (variable)
+          variable = parser.parseGroup() ?? parser.parseToken();
+          if (!variable) return null;
+        } else if (parser.match('^')) {
+          // Parse the superscript (degree)
+          const degExpr = parser.parseGroup() ?? parser.parseToken();
+          degree = machineValue(degExpr) ?? 1;
+        } else {
+          done = true;
+        }
+      }
+
+      // Only trigger if we have a subscript (to distinguish from D as a variable)
+      if (!variable) return null;
+
+      // Parse the function/expression to differentiate
+      parser.skipSpace();
+      const fn = parser.parseExpression({ minPrec: 740 });
+      if (!fn) return null;
+
+      // Build nested D for the degree
+      let result: Expression = fn;
+      for (let i = 0; i < degree; i++) {
+        result = ['D', result, variable] as Expression;
+      }
+      return result;
+    },
+  },
+
   {
     kind: 'environment',
     name: 'Which',
@@ -1199,6 +1293,14 @@ function parsePrime(
   lhs: Expression,
   order: number
 ): Expression | null {
+  // Accumulate additional prime marks (e.g., f''' -> order 3)
+  while (!parser.atEnd) {
+    if (parser.match("'") || parser.match('\\prime')) order++;
+    else if (parser.match('\\doubleprime')) order += 2;
+    else if (parser.match('\\tripleprime')) order += 3;
+    else break;
+  }
+
   // If the lhs is a Prime/Derivative, increase the derivation order
   const lhsh = operator(lhs);
   if (lhsh === 'Derivative' || lhsh === 'Prime') {
@@ -1211,6 +1313,31 @@ function parsePrime(
 
   const sym = symbol(lhs);
   if ((sym && parser.getSymbolType(sym).matches('function')) || operator(lhs)) {
+    // Check if followed by arguments - if so, use D notation
+    // e.g., f'(x) -> ["D", ["f", "x"], "x"]
+    parser.skipSpace();
+    const args = parser.parseArguments('enclosure');
+
+    if (args && args.length > 0) {
+      // Infer differentiation variable from first argument (if it's a symbol)
+      const firstArg = args[0];
+      const variable = symbol(firstArg) ?? 'x';
+
+      // Build function call: f(x, y, ...) -> ['f', x, y, ...]
+      const fnCall =
+        typeof lhs === 'string'
+          ? ([lhs, ...args] as Expression)
+          : (['Apply', lhs, ...args] as Expression);
+
+      // Wrap with nested D for the order
+      let result: Expression = fnCall;
+      for (let i = 0; i < order; i++) {
+        result = ['D', result, variable] as Expression;
+      }
+      return result;
+    }
+
+    // No arguments - return Derivative as before
     if (order === 1) return ['Derivative', lhs];
     return ['Derivative', lhs, order];
   }

src/compute-engine/latex-syntax/types.ts

@@ -796,6 +796,16 @@ export type ParseLatexOptions = NumberFormat & {
    * // parses as: ∀x. (P(x) → Q(x))
    */
   quantifierScope: 'tight' | 'loose';
+
+  /**
+   * The variable used for time derivatives in Newton notation
+   * (`\dot{x}`, `\ddot{x}`, etc.).
+   *
+   * When parsing `\dot{x}`, it will be interpreted as `["D", "x", timeDerivativeVariable]`.
+   *
+   * **Default:** `"t"`
+   */
+  timeDerivativeVariable: string;
 };
 
 /**

test/compute-engine/latex-syntax/__snapshots__/calculus.test.ts.snap

@@ -66,6 +66,36 @@ int^(1)(sin(x) dx)
 ]
 `;
 
+exports[`EULER DERIVATIVE NOTATION D without subscript - should parse as symbol 1`] = `
+D
+D
+D
+`;
+
+exports[`EULER DERIVATIVE NOTATION D^2_x f - second derivative 1`] = `
+D(x\\mapsto D(x\\mapsto f, x), x)
+D((x) |-> D((x) |-> f, x), x)
+["D", ["Function", ["D", ["Function", "f", "x"], "x"], "x"], "x"]
+`;
+
+exports[`EULER DERIVATIVE NOTATION D_t x - different variable 1`] = `
+D(t\\mapsto x, t)
+D((t) |-> x, t)
+["D", ["Function", "x", "t"], "t"]
+`;
+
+exports[`EULER DERIVATIVE NOTATION D_x (x^2 + 1) - derivative of expression 1`] = `
+D(x\\mapsto x^2+1, x)
+D((x) |-> x^2 + 1, x)
+["D", ["Function", ["Add", ["Square", "x"], 1], "x"], "x"]
+`;
+
+exports[`EULER DERIVATIVE NOTATION D_x f - first derivative 1`] = `
+D(x\\mapsto f, x)
+D((x) |-> f, x)
+["D", ["Function", "f", "x"], "x"]
+`;
+
 exports[`EXOTIC INTEGRALS \\iiint 1`] = `
 \\int\\int\\int_{V}\\!f(x, y, z)\\, \\mathrm{d}x \\mathrm{d}y \\mathrm{d}z
 int_(V)(f(x, y, z) dx  dy  dz)
@@ -386,6 +416,64 @@ int(sin(x) dx) + 1 === 2
 ]
 `;
 
+exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS \\sin'(x) - known function with prime 1`] = `
+D(x\\mapsto\\sin(x), x)
+D((x) |-> sin(x), x)
+["D", ["Function", ["Sin", "x"], "x"], "x"]
+`;
+
+exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f' without arguments - returns Derivative 1`] = `
+f^{\\prime}
+Derivative(f)
+["Derivative", "f"]
+`;
+
+exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f'''(x) - triple prime with argument 1`] = `
+D(x\\mapsto D(x\\mapsto D(x\\mapsto f(x), x), x), x)
+D((x) |-> D((x) |-> D((x) |-> f(x), x), x), x)
+[
+  "D",
+  [
+    "Function",
+    [
+      "D",
+      ["Function", ["D", ["Function", ["f", "x"], "x"], "x"], "x"],
+      "x"
+    ],
+    "x"
+  ],
+  "x"
+]
+`;
+
+exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f''(x) - double prime with argument 1`] = `
+D(x\\mapsto D(x\\mapsto f(x), x), x)
+D((x) |-> D((x) |-> f(x), x), x)
+[
+  "D",
+  ["Function", ["D", ["Function", ["f", "x"], "x"], "x"], "x"],
+  "x"
+]
+`;
+
+exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f'(x) - single prime with argument 1`] = `
+D(x\\mapsto f(x), x)
+D((x) |-> f(x), x)
+["D", ["Function", ["f", "x"], "x"], "x"]
+`;
+
+exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f'(x, y) - multiple arguments uses first as variable 1`] = `
+D(x\\mapsto f(x, y), x)
+D((x) |-> f(x, y), x)
+["D", ["Function", ["f", "x", "y"], "x"], "x"]
+`;
+
+exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS g'(t) - different variable 1`] = `
+(g^\\prime,t)
+(Prime(g), t)
+["Pair", ["Prime", "g"], "t"]
+`;
+
 exports[`MULTIPLE INTEGRALS Double integral 1`] = `
 \\int_{1}^{2}\\!\\int\\int_{0}^{1}\\!x^2+y^2\\, \\mathrm{d}x \\mathrm{d}y
 int_(1)^(2)(int_(0)^(1)(x^2 + y^2 dx  dy) dx  dy)
@@ -501,6 +589,74 @@ int_(1)^(2)(int_(0)^(1)(int_(3)^(4)(x^2 + y^2 + z^2 dx  dy  dz) dx  dy  dz) dx
 ]
 `;
 
+exports[`NEWTON DOT NOTATION Dot notation with expression 1`] = `
+\\mathtip{\\error{\\blacksquare}}{\\in \\text{expression}\\notin \\text{number}}+\\mathtip{\\error{\\blacksquare}}{\\in \\text{expression}\\notin \\text{number}}
+Error(ErrorCode("incompatible-type", "number", "expression")) + Error(ErrorCode("incompatible-type", "number", "expression"))
+[
+  "Add",
+  [
+    "Error",
+    ["ErrorCode", "incompatible-type", "'number'", "'expression'"]
+  ],
+  [
+    "Error",
+    ["ErrorCode", "incompatible-type", "'number'", "'expression'"]
+  ]
+]
+`;
+
+exports[`NEWTON DOT NOTATION First derivative \\dot{x} 1`] = `
+D(t\\mapsto x, t)
+D((t) |-> x, t)
+["D", ["Function", "x", "t"], "t"]
+`;
+
+exports[`NEWTON DOT NOTATION Fourth derivative \\ddddot{z} 1`] = `
+D(t\\mapsto D(t\\mapsto D(t\\mapsto D(t\\mapsto z, t), t), t), t)
+D((t) |-> D((t) |-> D((t) |-> D((t) |-> z, t), t), t), t)
+[
+  "D",
+  [
+    "Function",
+    [
+      "D",
+      [
+        "Function",
+        [
+          "D",
+          ["Function", ["D", ["Function", "z", "t"], "t"], "t"],
+          "t"
+        ],
+        "t"
+      ],
+      "t"
+    ],
+    "t"
+  ],
+  "t"
+]
+`;
+
+exports[`NEWTON DOT NOTATION Second derivative \\ddot{x} 1`] = `
+D(t\\mapsto D(t\\mapsto x, t), t)
+D((t) |-> D((t) |-> x, t), t)
+["D", ["Function", ["D", ["Function", "x", "t"], "t"], "t"], "t"]
+`;
+
+exports[`NEWTON DOT NOTATION Third derivative \\dddot{y} 1`] = `
+D(t\\mapsto D(t\\mapsto D(t\\mapsto y, t), t), t)
+D((t) |-> D((t) |-> D((t) |-> y, t), t), t)
+[
+  "D",
+  [
+    "Function",
+    ["D", ["Function", ["D", ["Function", "y", "t"], "t"], "t"], "t"],
+    "t"
+  ],
+  "t"
+]
+`;
+
 exports[`REAL WORLD INTEGRALS Integral with non standard typesetting 1`] = `
 \\mathrm{S_{t}}=\\mathrm{S_0}+\\int_{\\mathrm{t_{i}}}^{\\mathrm{t_{e}}}\\!G-F\\, \\mathrm{d}t
 "S_t" === "S_0" + int_("t_i")^("t_e")(-F + "CatalanConstant" dF)