small fixes

Andreas-Hum · Aug 18, 2023 · edb8703 · edb8703
1 parent b22678e
commit edb8703
Show file tree

Hide file tree

Showing 2 changed files with 14 additions and 12 deletions.
diff --git a/src/math.ts b/src/math.ts
@@ -253,13 +253,13 @@ export namespace math {
  throw new NumericalError("The vector is either a number array nor a bigint array and no appropriate Numeric implementation was provided.", 901);
  }
  }
- let squaredValues: T[] = vector.map((value: T) => numerical.multiply(value, value));
- let sumOfSquares: T = squaredValues.reduce((acc: T, value: T) => numerical.add(acc, value), numerical.zeroValue);
+ let squaredValues: T[] = vector.map((value: T) => numerical!.multiply(value, value));
+ let sumOfSquares: T = squaredValues.reduce((acc: T, value: T) => numerical!.add(acc, value), numerical.zeroValue);
  if (sumOfSquares === numerical.zeroValue) {
  throw new Error("Can't normalize a zero vector")
  }
  let scalar: T = numerical.divide(numerical.oneValue, numerical.sqrt(sumOfSquares));
- return vector.map((entry: T) => numerical.multiply(entry, scalar));
+ return vector.map((entry: T) => numerical!.multiply(entry, scalar));
  }
 
  /**
@@ -388,7 +388,7 @@ export namespace math {
  }
 
  if (array.length === 1) return array[0]
- return array.reduce((acc: T, cur: T) => numerical.multiply(acc, cur), numerical.oneValue);
+ return array.reduce((acc: T, cur: T) => numerical!.multiply(acc, cur), numerical.oneValue);
  }
 
 
@@ -524,7 +524,7 @@ export namespace math {
  }
 
  if (array.length === 1) return array[0]
- return array.reduce((acc: T, cur: T) => numerical.add(acc, cur), numerical.zeroValue);
+ return array.reduce((acc: T, cur: T) => numerical!.add(acc, cur), numerical.zeroValue);
 
  }
 

diff --git a/src/matrix.ts b/src/matrix.ts
@@ -133,8 +133,8 @@ export class Matrix<T> implements MatrixInterface<T, any> {
  }
 
  if (this.is1dArray(entries)) {
- const rows: number | undefined = options.rows;
- const columns: number | undefined = options.columns;
+ const rows: number | undefined = options!.rows;
+ const columns: number | undefined = options!.columns;
 
  if (rows === undefined || columns === undefined || typeof (rows) !== "number" || typeof (columns) !== "number" || columns <= 0 || rows <= 0) {
  throw new MatrixError("Rows and columns must be defined for 1D array entries, rows and columns must be of type number and not be 0 or negative", 804);
@@ -976,27 +976,29 @@ export class Matrix<T> implements MatrixInterface<T, any> {
  const secondDiag: T = this.numerical.multiply(this.mElements[1], this.mElements[2]);
  return this.numerical.toIntegral(this.numerical.subtract(firstDiag, secondDiag))
  }
-
+ let numb: number
 
 
  try {
 
  let { L, U, P, permutationCount } = this.LUDecomposition();
  const det: T = math.prod(U.diag(), this.numerical);
 
- let numb: number = this.numerical.toIntegral(det);
+ numb = this.numerical.toIntegral(det);
  if (math.abs(numb) < Constants.DELTA) return 0
  // If permutationCount is odd, multiply det with -1
  if (permutationCount % 2) {
  numb *= -1;
  }
 
- return numb
  } catch (error: any) {
  if (error.message === "Matrix is singular. LU decomposition cannot be performed.") return 0;
  }
 
 
+ //@ts-ignore
+ return numb
+
 
  }
 
@@ -2643,7 +2645,7 @@ export class Matrix<T> implements MatrixInterface<T, any> {
  }
 
  if (rows <= 0 || columns <= 0 || typeof rows !== "number" || typeof columns !== "number") throw new MatrixError("Invalid argument", 606, { rows, columns });
- return new Matrix<T>(new Array(rows).fill(numerical.zeroValue).map(() => new Array(columns).fill(numerical.oneValue)), { numerical })
+ return new Matrix<T>(new Array(rows).fill(numerical.zeroValue).map(() => new Array(columns).fill(numerical!.oneValue)), { numerical })
  }
 
 
@@ -2710,7 +2712,7 @@ export class Matrix<T> implements MatrixInterface<T, any> {
  numerical = new NumericalNumber() as unknown as Numerical<T>;
  }
  if (rows <= 0 || columns <= 0 || typeof rows !== "number" || typeof columns !== "number") throw new MatrixError("Invalid argument", 606, { rows, columns });
- return new Matrix<T>(new Array(rows).fill(numerical.zeroValue).map(() => new Array(columns).fill(numerical.zeroValue)), { numerical })
+ return new Matrix<T>(new Array(rows).fill(numerical.zeroValue).map(() => new Array(columns).fill(numerical!.zeroValue)), { numerical })
  }