Features:

	- Single Vector Norm Evaluator Annotation (1)
	- Single Vector Norm 1 Evaluator (2, 3, 4)
	- Single Vector Norm 2 Evaluator (5, 6)
	- Single Vector Norm Infinity Evaluator (7, 8, 9)
	- Double Vector Norm Evaluator #1 (10, 11, 12)
	- Double Vector Norm Evaluator #2 (13, 14, 15)
	- Single Vector Norm Evaluator Constructor (16, 17, 18)
	- Double Vector Two Infinity Evaluator Shell (19, 20, 21)
	- Double Vector Two Infinity Evaluator Constructor (22, 23, 24)
	- Double Vector Two Infinity Evaluator Norm (25, 26, 27)
	- Double Vector One Two Evaluator Shell (28, 29)
	- Double Vector One Two Evaluator Constructor (30, 31)
	- Double Vector One Two Evaluator Norm (32, 33)
	- Matrix-Matrix Sub-multiplicative Consistency Validation (37, 38, 39)
	- Matrix-Matrix Sub-additive Consistency Validation (40, 41, 42)
	- Matrix Vector Sub-multiplicative Consistency #1 (43, 44, 45)
	- Matrix Vector Sub-multiplicative Consistency #2 (46, 47, 48)
	- Matrix Vector Sub-multiplicative Consistency #3 (49, 50, 51)
	- Util Unsafe Matrix Vector Product #1 (52, 53, 54)
	- Util Safe Matrix Vector Product #1 (55, 56, 57)
	- Util Unsafe Matrix Vector Product #2 (58, 59, 60)
	- Util Safe Matrix Vector Product #2 (61, 62, 63)
	- Util Safe Matrix Vector Product #3 (64, 65, 66)
	- Square Evaluator Consistency Validator #1 (67, 68, 69)
	- Square Evaluator Consistency Validator #2 (70, 71, 72)
	- Single Compatible Vector Evaluator p-Norm (73, 74, 75)
	- Entry-wise Norm Evaluator Shell #1 (76, 77, 78)
	- Entry-wise Evaluator p Norm (79, 80, 81)
	- Entry-wise Evaluator q Norm (82, 83, 84)
	- Entry-wise Evaluator pq Norm #1 (85, 86, 87)
	- Entry-wise Evaluator pq Norm #2 (88, 89)
	- Entry-wise Evaluator pq Norm Constructor (90, 91, 92)
	- Entry-wise Evaluator pq Norm 2_1 (93, 94, 95)
	- Entry-wise Evaluator pq Norm p_p (96, 97, 98)
	- Matrix Util Unsafe Trace #1 (99, 100)
	- Matrix Util Unsafe Trace #2 (101, 102)
	- R1 Matrix Util Trace Evaluator (103, 104, 105)
	- R1 Square Matrix Trace Evaluator (106, 107, 108)
	- Entry-wise Frobenius Evaluator Shell (109, 110, 111)
	- Entry-wise Frobenius Evaluator Constructor (112, 113, 114)
	- Entry-wise Frobenius Evaluator Norm (115, 116, 117)
	- Entry-wise Frobenius Evaluator Trace Norm (118, 119, 120)


Bug Fixes/Re-organization:

	- R1 Square Consistency Validator Criteria (34, 35, 36)


Samples:

IdeaDRIP:

ReleaseNotes/04_09_2024.txt

@@ -0,0 +1,55 @@
+
+Features:
+
+	- Single Vector Norm Evaluator Annotation (1)
+	- Single Vector Norm 1 Evaluator (2, 3, 4)
+	- Single Vector Norm 2 Evaluator (5, 6)
+	- Single Vector Norm Infinity Evaluator (7, 8, 9)
+	- Double Vector Norm Evaluator #1 (10, 11, 12)
+	- Double Vector Norm Evaluator #2 (13, 14, 15)
+	- Single Vector Norm Evaluator Constructor (16, 17, 18)
+	- Double Vector Two Infinity Evaluator Shell (19, 20, 21)
+	- Double Vector Two Infinity Evaluator Constructor (22, 23, 24)
+	- Double Vector Two Infinity Evaluator Norm (25, 26, 27)
+	- Double Vector One Two Evaluator Shell (28, 29)
+	- Double Vector One Two Evaluator Constructor (30, 31)
+	- Double Vector One Two Evaluator Norm (32, 33)
+	- Matrix-Matrix Sub-multiplicative Consistency Validation (37, 38, 39)
+	- Matrix-Matrix Sub-additive Consistency Validation (40, 41, 42)
+	- Matrix Vector Sub-multiplicative Consistency #1 (43, 44, 45)
+	- Matrix Vector Sub-multiplicative Consistency #2 (46, 47, 48)
+	- Matrix Vector Sub-multiplicative Consistency #3 (49, 50, 51)
+	- Util Unsafe Matrix Vector Product #1 (52, 53, 54)
+	- Util Safe Matrix Vector Product #1 (55, 56, 57)
+	- Util Unsafe Matrix Vector Product #2 (58, 59, 60)
+	- Util Safe Matrix Vector Product #2 (61, 62, 63)
+	- Util Safe Matrix Vector Product #3 (64, 65, 66)
+	- Square Evaluator Consistency Validator #1 (67, 68, 69)
+	- Square Evaluator Consistency Validator #2 (70, 71, 72)
+	- Single Compatible Vector Evaluator p-Norm (73, 74, 75)
+	- Entry-wise Norm Evaluator Shell #1 (76, 77, 78)
+	- Entry-wise Evaluator p Norm (79, 80, 81)
+	- Entry-wise Evaluator q Norm (82, 83, 84)
+	- Entry-wise Evaluator pq Norm #1 (85, 86, 87)
+	- Entry-wise Evaluator pq Norm #2 (88, 89)
+	- Entry-wise Evaluator pq Norm Constructor (90, 91, 92)
+	- Entry-wise Evaluator pq Norm 2_1 (93, 94, 95)
+	- Entry-wise Evaluator pq Norm p_p (96, 97, 98)
+	- Matrix Util Unsafe Trace #1 (99, 100)
+	- Matrix Util Unsafe Trace #2 (101, 102)
+	- R1 Matrix Util Trace Evaluator (103, 104, 105)
+	- R1 Square Matrix Trace Evaluator (106, 107, 108)
+	- Entry-wise Frobenius Evaluator Shell (109, 110, 111)
+	- Entry-wise Frobenius Evaluator Constructor (112, 113, 114)
+	- Entry-wise Frobenius Evaluator Norm (115, 116, 117)
+	- Entry-wise Frobenius Evaluator Trace Norm (118, 119, 120)
+
+
+Bug Fixes/Re-organization:
+
+	- R1 Square Consistency Validator Criteria (34, 35, 36)
+
+
+Samples:
+
+IdeaDRIP:

src/main/java/org/drip/numerical/linearalgebra/R1MatrixUtil.java

@@ -215,6 +215,70 @@ public static final double[][] UnsafeProduct (
 		return product;
 	}
 
+	/**
+	 * Compute the Product of an Input Matrix and a Vector. Unsafe Methods do not validate the Input
+	 * 	Arguments, so <b>use caution</b> in applying these Methods
+	 * 
+	 * @param a Matrix A
+	 * @param b Vector B
+	 * 
+	 * @return The Product
+	 */
+
+	public static final double[] UnsafeProduct (
+		final double[][] a,
+		final double[] b)
+	{
+		double[] product = new double[a.length];
+
+		for (int rowIndex = 0; rowIndex < a.length; ++rowIndex) {
+			product[rowIndex] = 0.;
+
+			for (int columnIndex = 0; columnIndex < a[0].length; ++columnIndex) {
+				if (!NumberUtil.IsValid (a[rowIndex][columnIndex]) || !NumberUtil.IsValid (b[columnIndex])) {
+					return null;
+				}
+
+				product[rowIndex] += a[rowIndex][columnIndex] * b[columnIndex];
+			}
+		}
+
+		return product;
+	}
+
+	/**
+	 * Compute the Product of an Input Vector and a Matrix. Unsafe Methods do not validate the Input
+	 * 	Arguments, so <b>use caution</b> in applying these Methods
+	 * 
+	 * @param a Column A
+	 * @param b Matrix B
+	 * 
+	 * @return The Product
+	 */
+
+	public static final double[][] UnsafeProduct (
+		final double[] a,
+		final double[][] b)
+	{
+		double[][] product = new double[a.length][b.length];
+
+		for (int rowIndex = 0; rowIndex < a.length; ++rowIndex) {
+			for (int columnIndex = 0; columnIndex < b.length; ++columnIndex) {
+				product[rowIndex][columnIndex] = 0.;
+
+				for (int i = 0; i < a.length; ++i) {
+					if (!NumberUtil.IsValid (a[rowIndex]) || !NumberUtil.IsValid (b[i][columnIndex])) {
+						return null;
+					}
+
+					product[rowIndex][columnIndex] += a[rowIndex] * b[i][columnIndex];
+				}
+			}
+		}
+
+		return product;
+	}
+
 	/**
 	 * Compute the Addition of the Input Matrices. Unsafe Methods do not validate the Input Arguments, so
 	 * 	<b>use caution</b> in applying these Methods
@@ -270,6 +334,7 @@ public static final double[][] UnsafeSubtract (
 	 * 	caution</b> in applying these Methods
 	 * 
 	 * @param a Vector A
+	 * @param k Power Exponent
 	 * 
 	 * @return The Power Matrix
 	 */
@@ -289,6 +354,34 @@ public static final double[][] UnsafePower (
 		return aPower;
 	}
 
+	/**
+	 * Compute the Trace of the Input Matrix. Unsafe Methods do not validate the Input Arguments, so <b>use
+	 * 	caution</b> in applying these Methods
+	 * 
+	 * @param a Vector A
+	 * 
+	 * @return The Trace
+	 * 
+	 * @throws Exception Thrown if Trace cannot be Calculated
+	 */
+
+	public static final double UnsafeTrace (
+		final double[][] a)
+		throws Exception
+	{
+		double trace = 0.;
+
+		for (int i = 0; i < a.length; ++i) {
+			if (!NumberUtil.IsValid (a[i][i])) {
+				throw new Exception ("R1MatrixUtil::UnsafeTrace => Invalid Matrix Entry");
+			}
+
+			trace += a[i][i];
+		}
+
+		return trace;
+	}
+
 	/**
 	 * Orthogonalize the Specified Matrix Using the RQ Graham-Schmidt Method. Unsafe Methods do not validate
 	 * 	the Input Arguments, so <b>use caution</b> in applying these Methods
@@ -427,79 +520,37 @@ public static final boolean DiagonalizeRow (
 	}
 
 	/**
-	 * Compute the Product of an Input Matrix and a Column
+	 * Compute the Product of an Input Matrix and a Vector
 	 * 
-	 * @param aadblA Matrix A
-	 * @param adblB Array B
+	 * @param a Matrix A
+	 * @param b Array B
 	 * 
 	 * @return The Product
 	 */
 
 	public static final double[] Product (
-		final double[][] aadblA,
-		final double[] adblB)
+		final double[][] a,
+		final double[] b)
 	{
-		if (null == aadblA || null == adblB) return null;
-
-		int iNumACol = aadblA[0].length;
-		int iNumProductCol = adblB.length;
-		int iNumProductRow = aadblA.length;
-		double[] adblProduct = new double[iNumProductRow];
-
-		if (0 == iNumACol || iNumACol != adblB.length || 0 == iNumProductRow || 0 == iNumProductCol)
-			return null;
-
-		for (int iRow = 0; iRow < iNumProductRow; ++iRow) {
-			adblProduct[iRow] = 0.;
-
-			for (int i = 0; i < iNumACol; ++i) {
-				if (!org.drip.numerical.common.NumberUtil.IsValid (aadblA[iRow][i]) ||
-					!org.drip.numerical.common.NumberUtil.IsValid (adblB[i]))
-					return null;
-
-				adblProduct[iRow] += aadblA[iRow][i] * adblB[i];
-			}
-		}
-
-		return adblProduct;
+		return null == a || null == b || 0 == a.length || 0 == a[0].length || a[0].length != b.length ?
+			null : UnsafeProduct (a, b);
 	}
 
 	/**
-	 * Compute the Product of an input column and a matrix
+	 * Compute the Product of an Input Vector and a Matrix
 	 * 
-	 * @param adblA Column A
-	 * @param aadblB Matrix B
+	 * @param a Vector A
+	 * @param b Matrix B
 	 * 
 	 * @return The Product
 	 */
 
 	public static final double[][] Product (
-		final double[] adblA,
-		final double[][] aadblB)
+		final double[] a,
+		final double[][] b)
 	{
-		if (null == adblA || null == aadblB) return null;
-
-		int iNumACol = adblA.length;
-		int iNumProductCol = aadblB.length;
-		double[][] aadblProduct = new double[iNumACol][iNumProductCol];
-
-		if (0 == iNumACol || iNumACol != aadblB.length || 0 == iNumProductCol) return null;
-
-		for (int iRow = 0; iRow < iNumACol; ++iRow) {
-			for (int iCol = 0; iCol < iNumProductCol; ++iCol) {
-				aadblProduct[iRow][iCol] = 0.;
-
-				for (int i = 0; i < iNumACol; ++i) {
-					if (!org.drip.numerical.common.NumberUtil.IsValid (adblA[iRow]) ||
-						!org.drip.numerical.common.NumberUtil.IsValid (aadblB[i][iCol]))
-						return null;
-
-					aadblProduct[iRow][iCol] += adblA[iRow] * aadblB[i][iCol];
-				}
-			}
-		}
-
-		return aadblProduct;
+		return null == a || null == b || 0 == a.length || a.length != b.length || 0 == b[0].length ?
+			null : UnsafeProduct (a, b);
 	}
 
 	/**
@@ -572,6 +623,27 @@ public static final double[][] Power (
 		return null == a || 0 == a.length || 0 == a[0].length || 0 >= k ? null : UnsafePower (a, k);
 	}
 
+	/**
+	 * Compute the Trace of the Input Matrix
+	 * 
+	 * @param a Vector A
+	 * 
+	 * @return The Trace
+	 * 
+	 * @throws Exception Thrown if Trace cannot be Calculated
+	 */
+
+	public static final double Trace (
+		final double[][] a)
+		throws Exception
+	{
+		if (null == a || 0 == a.length || 0 == a[0].length) {
+			throw new Exception ("R1MatrixUtil::Trace => Invalid Input Matrix");
+		}
+
+		return UnsafeTrace (a);
+	}
+
 	/**
 	 * Compute the Sum of the input matrices
 	 * 

src/main/java/org/drip/numerical/matrix/R1Square.java

@@ -176,6 +176,23 @@ public int size()
 		return _r1Grid.length;
 	}
 
+	/**
+	 * Compute the Trace
+	 * 
+	 * @return The Trace
+	 */
+
+	public double trace()
+	{
+		double trace = 0.;
+
+		for (int i = 0; i < _r1Grid.length; ++i) {
+			trace += _r1Grid[i][i];
+		}
+
+		return trace;
+	}
+
 	/**
 	 * Transpose the Square Matrix
 	 * 
@@ -304,6 +321,40 @@ public R1Square multiply (
 		return new R1Square (r1GridProduct);
 	}
 
+	/**
+	 * Compute the Product with the Vector
+	 * 
+	 * @param r1Array Vector Array
+	 * 
+	 * @return Resulting Matrix
+	 */
+
+	public R1Square multiply (
+		final double[] r1Array)
+	{
+		if (null == r1Array || 0 == r1Array.length || r1Array.length != _r1Grid.length) {
+			return null;
+		}
+
+		double[][] r1GridProduct = new double[_r1Grid.length][_r1Grid.length];
+
+		for (int rowIndex = 0; rowIndex < r1Array.length; ++rowIndex) {
+			for (int columnIndex = 0; columnIndex < _r1Grid.length; ++columnIndex) {
+				r1GridProduct[rowIndex][columnIndex] = 0.;
+
+				for (int i = 0; i < r1Array.length; ++i) {
+					if (!NumberUtil.IsValid (r1Array[rowIndex])) {
+						return null;
+					}
+
+					r1GridProduct[rowIndex][columnIndex] += r1Array[rowIndex] * _r1Grid[i][columnIndex];
+				}
+			}
+		}
+
+		return new R1Square (r1GridProduct);
+	}
+
 	/**
 	 * Calculate whether the Matrix is "Normal"
 	 *