feat: implement norm computation for vectors and matrices with corresponding tests

Author: arnog

src/compute-engine/library/linear-algebra.ts

@@ -586,6 +586,166 @@ export const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[] = [
         return ce.box(['List', ...rows]);
       },
     },
+
+    // Computes vector and matrix norms
+    // For vectors:
+    //   - L2 (Euclidean, default): √(Σ|xi|²)
+    //   - L1: Σ|xi|
+    //   - L∞ (max): max(|xi|)
+    //   - Lp: (Σ|xi|^p)^(1/p)
+    // For matrices:
+    //   - Frobenius (default): √(ΣΣ|aij|²)
+    Norm: {
+      complexity: 8200,
+      signature: '(value, number|string?) -> number',
+      evaluate: (ops, { engine: ce }): BoxedExpression | undefined => {
+        const x = ops[0].evaluate();
+        const normTypeExpr = ops.length > 1 ? ops[1].evaluate() : undefined;
+
+        // Scalar: |x| (absolute value)
+        if (x.isNumber) {
+          return ce.box(['Abs', x]).evaluate();
+        }
+
+        if (!isBoxedTensor(x)) return undefined;
+
+        const shape = x.shape;
+
+        // Determine norm type
+        let normType: number | string = 2; // Default to L2/Frobenius
+        if (normTypeExpr) {
+          if (
+            normTypeExpr.string === 'Infinity' ||
+            normTypeExpr.symbol === 'Infinity' ||
+            normTypeExpr.re === Infinity
+          ) {
+            normType = 'infinity';
+          } else if (normTypeExpr.string === 'Frobenius') {
+            normType = 'frobenius';
+          } else if (normTypeExpr.re !== undefined) {
+            normType = normTypeExpr.re;
+          }
+        }
+
+        // Vector norm (rank 1)
+        if (shape.length === 1) {
+          const elements: BoxedExpression[] = [];
+          const n = shape[0];
+          for (let i = 0; i < n; i++) {
+            const val = x.tensor.at(i + 1);
+            elements.push(val !== undefined ? ce.box(val) : ce.Zero);
+          }
+
+          if (normType === 1) {
+            // L1 norm: sum of absolute values
+            let sum: BoxedExpression = ce.Zero;
+            for (const el of elements) {
+              sum = sum.add(ce.box(['Abs', el]).evaluate());
+            }
+            return sum.evaluate();
+          }
+
+          if (normType === 2) {
+            // L2 norm: sqrt of sum of squares
+            let sumSq: BoxedExpression = ce.Zero;
+            for (const el of elements) {
+              const absEl = ce.box(['Abs', el]).evaluate();
+              sumSq = sumSq.add(absEl.mul(absEl));
+            }
+            return ce.box(['Sqrt', sumSq]).evaluate();
+          }
+
+          if (normType === 'infinity') {
+            // L∞ norm: max absolute value
+            let maxVal: BoxedExpression = ce.Zero;
+            for (const el of elements) {
+              const absEl = ce.box(['Abs', el]).evaluate();
+              // Compare: use numeric comparison
+              const absNum = absEl.re ?? 0;
+              const maxNum = maxVal.re ?? 0;
+              if (absNum > maxNum) {
+                maxVal = absEl;
+              }
+            }
+            return maxVal;
+          }
+
+          // General Lp norm: (Σ|xi|^p)^(1/p)
+          if (typeof normType === 'number' && normType > 0) {
+            const p = normType;
+            let sumPow: BoxedExpression = ce.Zero;
+            for (const el of elements) {
+              const absEl = ce.box(['Abs', el]).evaluate();
+              sumPow = sumPow.add(ce.box(['Power', absEl, p]).evaluate());
+            }
+            // Use Root for integer p values, Power for non-integer
+            // Use .N() to get numeric result for non-perfect roots
+            if (Number.isInteger(p)) {
+              return ce.box(['Root', sumPow, p]).N();
+            }
+            return ce.box(['Power', sumPow, ce.box(['Divide', 1, p])]).N();
+          }
+
+          return undefined;
+        }
+
+        // Matrix norm (rank 2)
+        if (shape.length === 2) {
+          const [m, n] = shape;
+
+          // Frobenius norm (default for matrices): √(ΣΣ|aij|²)
+          if (normType === 2 || normType === 'frobenius') {
+            let sumSq: BoxedExpression = ce.Zero;
+            for (let i = 0; i < m; i++) {
+              for (let j = 0; j < n; j++) {
+                const val = x.tensor.at(i + 1, j + 1);
+                const el = val !== undefined ? ce.box(val) : ce.Zero;
+                const absEl = ce.box(['Abs', el]).evaluate();
+                sumSq = sumSq.add(absEl.mul(absEl));
+              }
+            }
+            return ce.box(['Sqrt', sumSq]).evaluate();
+          }
+
+          // L1 (max column sum of absolute values)
+          if (normType === 1) {
+            let maxColSum = 0;
+            for (let j = 0; j < n; j++) {
+              let colSum = 0;
+              for (let i = 0; i < m; i++) {
+                const val = x.tensor.at(i + 1, j + 1);
+                const el = val !== undefined ? ce.box(val) : ce.Zero;
+                const absEl = ce.box(['Abs', el]).evaluate();
+                colSum += absEl.re ?? 0;
+              }
+              if (colSum > maxColSum) maxColSum = colSum;
+            }
+            return ce.number(maxColSum);
+          }
+
+          // L∞ (max row sum of absolute values)
+          if (normType === 'infinity') {
+            let maxRowSum = 0;
+            for (let i = 0; i < m; i++) {
+              let rowSum = 0;
+              for (let j = 0; j < n; j++) {
+                const val = x.tensor.at(i + 1, j + 1);
+                const el = val !== undefined ? ce.box(val) : ce.Zero;
+                const absEl = ce.box(['Abs', el]).evaluate();
+                rowSum += absEl.re ?? 0;
+              }
+              if (rowSum > maxRowSum) maxRowSum = rowSum;
+            }
+            return ce.number(maxRowSum);
+          }
+
+          return undefined;
+        }
+
+        // Higher-rank tensors: not supported yet
+        return undefined;
+      },
+    },
   },
 ];
 

test/compute-engine/linear-algebra.test.ts

@@ -832,3 +832,150 @@ describe('OnesMatrix', () => {
     );
   });
 });
+
+describe('Norm', () => {
+  // Scalar norm (absolute value)
+  it('should compute the norm of a scalar', () => {
+    const result = ce.box(['Norm', 5]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`5`);
+  });
+
+  it('should compute the norm of a negative scalar', () => {
+    const result = ce.box(['Norm', -7]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`7`);
+  });
+
+  // Vector L2 norm (default)
+  it('should compute the L2 norm of a vector (3-4-5 triangle)', () => {
+    // √(3² + 4²) = √(9 + 16) = √25 = 5
+    const result = ce.box(['Norm', ['List', 3, 4]]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`5`);
+  });
+
+  it('should compute the L2 norm of a vector with negatives', () => {
+    // √(3² + (-4)²) = 5
+    const result = ce.box(['Norm', ['List', 3, -4]]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`5`);
+  });
+
+  it('should compute the L2 norm of a 3D vector', () => {
+    // √(1² + 2² + 2²) = √(1 + 4 + 4) = √9 = 3
+    const result = ce.box(['Norm', ['List', 1, 2, 2]]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`3`);
+  });
+
+  // Vector L1 norm
+  it('should compute the L1 norm of a vector', () => {
+    // |3| + |-4| = 3 + 4 = 7
+    const result = ce.box(['Norm', ['List', 3, -4], 1]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`7`);
+  });
+
+  it('should compute the L1 norm of a longer vector', () => {
+    // |1| + |-2| + |3| + |-4| = 1 + 2 + 3 + 4 = 10
+    const result = ce.box(['Norm', ['List', 1, -2, 3, -4], 1]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`10`);
+  });
+
+  // Vector L∞ norm (max absolute value)
+  it('should compute the L-infinity norm of a vector', () => {
+    // max(|3|, |-4|) = 4
+    const result = ce
+      .box(['Norm', ['List', 3, -4], 'Infinity'])
+      .evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`4`);
+  });
+
+  it('should compute the L-infinity norm with string', () => {
+    // max(|1|, |-5|, |3|) = 5
+    const result = ce
+      .box(['Norm', ['List', 1, -5, 3], { str: 'Infinity' }])
+      .evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`5`);
+  });
+
+  // Vector Lp norm (general)
+  it('should compute the L3 norm of a vector', () => {
+    // (|3|³ + |4|³)^(1/3) = (27 + 64)^(1/3) = 91^(1/3) ≈ 4.498
+    const result = ce.box(['Norm', ['List', 3, 4], 3]).evaluate();
+    expect(result.re).toBeCloseTo(4.4979, 3);
+  });
+
+  it('should compute the L4 norm of a vector', () => {
+    // (|2|⁴ + |2|⁴)^(1/4) = (16 + 16)^(1/4) = 32^(1/4) ≈ 2.378
+    const result = ce.box(['Norm', ['List', 2, 2], 4]).evaluate();
+    expect(result.re).toBeCloseTo(2.3784, 3);
+  });
+
+  // Matrix Frobenius norm (default)
+  it('should compute the Frobenius norm of a matrix', () => {
+    // √(1² + 2² + 3² + 4²) = √(1 + 4 + 9 + 16) = √30 ≈ 5.477
+    const result = ce.box(['Norm', sq2_n]).evaluate();
+    expect(result.re).toBeCloseTo(5.4772, 3);
+  });
+
+  it('should compute the Frobenius norm of a non-square matrix', () => {
+    // √(1² + 2² + 3² + 4² + 5² + 6²) = √(1+4+9+16+25+36) = √91 ≈ 9.539
+    const result = ce.box(['Norm', m23_n]).evaluate();
+    expect(result.re).toBeCloseTo(9.5394, 3);
+  });
+
+  it('should compute the Frobenius norm with explicit type', () => {
+    const result = ce
+      .box(['Norm', sq2_n, { str: 'Frobenius' }])
+      .evaluate();
+    expect(result.re).toBeCloseTo(5.4772, 3);
+  });
+
+  // Matrix L1 norm (max column sum)
+  it('should compute the L1 norm of a matrix', () => {
+    // [[1, 2], [3, 4]]
+    // Column sums: |1| + |3| = 4, |2| + |4| = 6
+    // max = 6
+    const result = ce.box(['Norm', sq2_n, 1]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`6`);
+  });
+
+  it('should compute the L1 norm of a matrix with negatives', () => {
+    // [[1, -2], [-3, 4]]
+    // Column sums: |1| + |-3| = 4, |-2| + |4| = 6
+    // max = 6
+    const result = ce
+      .box(['Norm', ['List', ['List', 1, -2], ['List', -3, 4]], 1])
+      .evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`6`);
+  });
+
+  // Matrix L∞ norm (max row sum)
+  it('should compute the L-infinity norm of a matrix', () => {
+    // [[1, 2], [3, 4]]
+    // Row sums: |1| + |2| = 3, |3| + |4| = 7
+    // max = 7
+    const result = ce
+      .box(['Norm', sq2_n, { str: 'Infinity' }])
+      .evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`7`);
+  });
+
+  it('should compute the L-infinity norm of a non-square matrix', () => {
+    // [[1, 2, 3], [4, 5, 6]]
+    // Row sums: 1 + 2 + 3 = 6, 4 + 5 + 6 = 15
+    // max = 15
+    const result = ce
+      .box(['Norm', m23_n, { str: 'Infinity' }])
+      .evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`15`);
+  });
+
+  // Zero vector
+  it('should compute the norm of a zero vector', () => {
+    const result = ce.box(['Norm', ['List', 0, 0, 0]]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`0`);
+  });
+
+  // Single element vector
+  it('should compute the norm of a single element vector', () => {
+    const result = ce.box(['Norm', ['List', -5]]).evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`5`);
+  });
+});