lint

Author: arnog

src/compute-engine/boxed-expression/match.ts

@@ -186,17 +186,12 @@ function matchOnce(
 
     // Special case: Match Divide(1, x) against a Power pattern
     // This handles cases like x^-1 which is canonicalized as 1/x
-    if (
-      operator === 'Power' &&
-      expr.operator === 'Divide' &&
-      expr.op1.is(1)
-    ) {
+    if (operator === 'Power' && expr.operator === 'Divide' && expr.op1.is(1)) {
       // Create a synthetic Power expression: Power(x, -1)
-      const powerExpr = ce.function(
-        'Power',
-        [expr.op2, ce.number(-1)],
-        { canonical: false, structural: true }
-      );
+      const powerExpr = ce.function('Power', [expr.op2, ce.number(-1)], {
+        canonical: false,
+        structural: true,
+      });
       const result = matchArguments(
         powerExpr,
         pattern.ops,

src/compute-engine/latex-syntax/parse-symbol.ts

@@ -302,7 +302,11 @@ export function parseSymbol(parser: Parser): MathJsonSymbol | null {
         // only simple tokens (letters, digits, and nested subscripts).
         // If it starts with '(' or contains operators, it's an expression.
         const firstToken = parser.peek;
-        if (firstToken === '(' || firstToken === '\\lparen' || firstToken === '\\left') {
+        if (
+          firstToken === '(' ||
+          firstToken === '\\lparen' ||
+          firstToken === '\\left'
+        ) {
           // Starts with parenthesis - it's an expression, not a symbol
           parser.index = underscoreIndex;
           break;
@@ -315,7 +319,12 @@ export function parseSymbol(parser: Parser): MathJsonSymbol | null {
         // - contains operators (converted to 'plus', 'minus', etc. by parseSymbolBody)
         // - doesn't end with closing brace
         const hasOperators = sub !== null && /plus|minus|times|ast/.test(sub);
-        if (sub === null || sub.includes(',') || hasOperators || parser.peek !== '<}>') {
+        if (
+          sub === null ||
+          sub.includes(',') ||
+          hasOperators ||
+          parser.peek !== '<}>'
+        ) {
           parser.index = underscoreIndex;
           break;
         }

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

@@ -1621,7 +1621,6 @@ export class _Parser implements Parser {
     if (this.atEnd) return lhs;
     console.assert(lhs !== null);
 
-
     const index = this.index;
     this.skipSpace();
 

src/compute-engine/library/arithmetic.ts

@@ -507,7 +507,8 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
     // Digamma function ψ(x) = d/dx ln(Γ(x)) = Γ'(x)/Γ(x)
     // Also known as the psi function
     Digamma: {
-      description: 'Digamma function, the logarithmic derivative of the gamma function',
+      description:
+        'Digamma function, the logarithmic derivative of the gamma function',
       wikidata: 'Q1142755',
       complexity: 8200,
       broadcastable: true,
@@ -530,7 +531,8 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
     // The n-th derivative of the digamma function
     // PolyGamma(0, x) = Digamma(x), PolyGamma(1, x) = Trigamma(x)
     PolyGamma: {
-      description: 'Polygamma function, the n-th derivative of the digamma function',
+      description:
+        'Polygamma function, the n-th derivative of the digamma function',
       wikidata: 'Q1817679',
       complexity: 8500,
       broadcastable: true,

src/compute-engine/library/calculus.ts

@@ -162,10 +162,7 @@ volumes
         if (f?.operator === 'D') return f;
         // Avoid evaluating symbolic derivative applications like Digamma'(x)
         // which would incorrectly evaluate to 0
-        if (
-          f?.operator === 'Apply' &&
-          f.op1?.operator === 'Derivative'
-        )
+        if (f?.operator === 'Apply' && f.op1?.operator === 'Derivative')
           return f;
         // If the result contains symbolic transcendentals (like ln(2)),
         // return it without full evaluation to preserve the symbolic form

src/compute-engine/symbolic/simplify-sum.ts

@@ -7,7 +7,7 @@ import type { BoxedExpression, RuleStep } from '../global-types';
 export function simplifySum(x: BoxedExpression): RuleStep | undefined {
   if (x.operator !== 'Sum') return undefined;
 
-  let body = x.op1;
+  const body = x.op1;
   const limits = x.op2;
   if (!body || !limits || limits.operator !== 'Limits') return undefined;
 
@@ -78,7 +78,10 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
     // = b(b+1)/2 - (a-1)a/2 = (b(b+1) - a(a-1)) / 2
     const a = lower;
     const b = upper;
-    const result = b.mul(b.add(ce.One)).sub(a.mul(a.sub(ce.One))).div(2);
+    const result = b
+      .mul(b.add(ce.One))
+      .sub(a.mul(a.sub(ce.One)))
+      .div(2);
     return { value: result.simplify(), because: 'triangular number' };
   }
 
@@ -149,7 +152,10 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
       const result = ce.function('Multiply', [
         ce.function('Power', [ce.number(-1), b]),
         ce.function('Floor', [
-          ce.function('Divide', [ce.function('Add', [b, ce.One]), ce.number(2)]),
+          ce.function('Divide', [
+            ce.function('Add', [b, ce.One]),
+            ce.number(2),
+          ]),
         ]),
       ]);
       return { value: result, because: 'alternating linear series' };
@@ -177,8 +183,7 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
         // c * n form - extract coefficient
         const coef = term.ops!.filter((op) => op.symbol !== index);
         if (coef.length === term.ops!.length - 1) {
-          const c =
-            coef.length === 1 ? coef[0] : ce.function('Multiply', coef);
+          const c = coef.length === 1 ? coef[0] : ce.function('Multiply', coef);
           coefficient = coefficient ? coefficient.add(c) : c;
         }
       } else {
@@ -274,10 +279,7 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
     let binomialN: BoxedExpression | null = null;
 
     for (const op of body.ops) {
-      if (
-        op.operator === 'Binomial' &&
-        op.op2?.symbol === index
-      ) {
+      if (op.operator === 'Binomial' && op.op2?.symbol === index) {
         hasBinomial = true;
         binomialN = op.op1 ?? null;
       } else if (
@@ -303,16 +305,19 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
     for (const op of body.ops) {
       if (op.symbol === index) {
         hasIndex = true;
-      } else if (
-        op.operator === 'Binomial' &&
-        op.op2?.symbol === index
-      ) {
+      } else if (op.operator === 'Binomial' && op.op2?.symbol === index) {
         hasBinomial = true;
         binomialN = op.op1 ?? null;
       }
     }
 
-    if (hasIndex && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 2) {
+    if (
+      hasIndex &&
+      hasBinomial &&
+      binomialN &&
+      upper.isSame(binomialN) &&
+      body.ops.length === 2
+    ) {
       // n * 2^(n-1)
       const n = binomialN;
       const result = ce.function('Multiply', [
@@ -328,18 +333,25 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
     hasBinomial = false;
 
     for (const op of body.ops) {
-      if (op.operator === 'Power' && op.op1?.symbol === index && op.op2?.is(2)) {
-        hasIndexSquared = true;
-      } else if (
-        op.operator === 'Binomial' &&
-        op.op2?.symbol === index
+      if (
+        op.operator === 'Power' &&
+        op.op1?.symbol === index &&
+        op.op2?.is(2)
       ) {
+        hasIndexSquared = true;
+      } else if (op.operator === 'Binomial' && op.op2?.symbol === index) {
         hasBinomial = true;
         binomialN = op.op1 ?? null;
       }
     }
 
-    if (hasIndexSquared && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 2) {
+    if (
+      hasIndexSquared &&
+      hasBinomial &&
+      binomialN &&
+      upper.isSame(binomialN) &&
+      body.ops.length === 2
+    ) {
       // n(n+1) * 2^(n-2)
       const n = binomialN;
       const result = ce.function('Multiply', [
@@ -356,18 +368,25 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
     hasBinomial = false;
 
     for (const op of body.ops) {
-      if (op.operator === 'Power' && op.op1?.symbol === index && op.op2?.is(3)) {
-        hasIndexCubed = true;
-      } else if (
-        op.operator === 'Binomial' &&
-        op.op2?.symbol === index
+      if (
+        op.operator === 'Power' &&
+        op.op1?.symbol === index &&
+        op.op2?.is(3)
       ) {
+        hasIndexCubed = true;
+      } else if (op.operator === 'Binomial' && op.op2?.symbol === index) {
         hasBinomial = true;
         binomialN = op.op1 ?? null;
       }
     }
 
-    if (hasIndexCubed && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 2) {
+    if (
+      hasIndexCubed &&
+      hasBinomial &&
+      binomialN &&
+      upper.isSame(binomialN) &&
+      body.ops.length === 2
+    ) {
       // n²(n+3) * 2^(n-3)
       const n = binomialN;
       const result = ce.function('Multiply', [
@@ -385,7 +404,11 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
     hasBinomial = false;
 
     for (const op of body.ops) {
-      if (op.operator === 'Power' && op.op1?.is(-1) && op.op2?.symbol === index) {
+      if (
+        op.operator === 'Power' &&
+        op.op1?.is(-1) &&
+        op.op2?.symbol === index
+      ) {
         hasAltTerm = true;
       } else if (op.symbol === index) {
         hasIndexTerm = true;
@@ -395,7 +418,14 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
       }
     }
 
-    if (hasAltTerm && hasIndexTerm && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 3) {
+    if (
+      hasAltTerm &&
+      hasIndexTerm &&
+      hasBinomial &&
+      binomialN &&
+      upper.isSame(binomialN) &&
+      body.ops.length === 3
+    ) {
       // For n >= 2, sum = 0
       return { value: ce.Zero, because: 'alternating weighted binomial sum' };
     }
@@ -422,11 +452,7 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
   }
 
   // Sum of k*(k+1): Sum(k*(k+1), [k, 1, n]) → n(n+1)(n+2)/3
-  if (
-    body.operator === 'Multiply' &&
-    body.ops?.length === 2 &&
-    lower.is(1)
-  ) {
+  if (body.operator === 'Multiply' && body.ops?.length === 2 && lower.is(1)) {
     const [op1, op2] = body.ops;
     // Check for k * (k+1) pattern
     const isKTimesKPlus1 =
@@ -506,7 +532,10 @@ export function simplifySum(x: BoxedExpression): RuleStep | undefined {
           // (n - 1) / n
           const n = upper;
           const result = n.sub(ce.One).div(n);
-          return { value: result, because: 'partial fractions (telescoping k*(k-1))' };
+          return {
+            value: result,
+            because: 'partial fractions (telescoping k*(k-1))',
+          };
         }
       }
     }

src/compute-engine/tensor/tensors.ts

@@ -336,7 +336,10 @@ export abstract class AbstractTensor<
   // Trace is the sum of the diagonal entries of a square matrix.
   // `\operatorname{tr}(A) = \sum_{i=1}^n a_{ii}`
   // For rank > 2, returns a tensor of traces over the last two axes (batch trace)
-  trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT] | AbstractTensor<DT> {
+  trace(
+    axis1?: number,
+    axis2?: number
+  ): undefined | DataTypeMap[DT] | AbstractTensor<DT> {
     const rank = this.rank;
 
     // For rank < 2, trace is not defined