Features:

	- SSOR Pre-conditioning Iteration #1 (9, 10)
	- SSOR Pre-conditioning Iteration #2 (11, 12)
	- SSOR Pre-conditioning Iteration #3 (13, 14, 15)
	- Symmetric Successive Over-relaxation Pre-conditioner (16)
	- Service Env Invocation Manager Year (24)
	- Print 1D Array Row #1 (32, 33)
	- Print 1D Array Row #2 (34, 35)
	- Successive Over Relaxation Iterator Setting (38, 39)
	- Print 1D Array Row #3 (63, 64)
	- String Util From Boolean Flag (83, 84)
	- SOR Convergence Check Standard Instance (102, 103, 104)


Bug Fixes/Re-organization:

	- SOR Convergence Check Constructor Fix (88)
	- SOR Convergence Jacobi Iteration Matrix (111, 112)


Samples:

	- Successive Over-relaxation Customization/Usage (17, 18)
	- Forward Substitution Solver Annotated Shell (19, 20, 21)
	- Forward Substitution Solver Entry Point (22, 23)
	- SOR Forward Substitution Solver #1 (25, 26)
	- SOR Forward Substitution Solver #2 (27, 28, 29)
	- SOR Forward Substitution Solver #3 (30, 31)
	- SOR Forward Substitution Solver #4 (36, 37)
	- SOR Forward Substitution Solver #5 (40, 41, 42)
	- SOR Forward Substitution Solver #6 (43, 44)
	- SOR Forward Substitution Solver #7 (45, 46)
	- SOR Forward Substitution Solver #8 (47, 48)
	- SOR Forward Substitution Solver #9 (49, 50)
	- SOR Forward Substitution Solver #10 (51, 52)
	- SOR Forward Substitution Solver #11 (53, 54)
	- SOR Forward Substitution Solver #12 (55, 56)
	- SOR Forward Substitution Solver #13 (57, 58)
	- SOR Forward Substitution Solver #14 (59, 60)
	- Forward Substitution Relaxation Array #1 (61, 62)
	- Forward Substitution Relaxation Array #2 (65, 66)
	- Forward Substitution Relaxation Array #3 (67, 68)
	- Forward Substitution Relaxation Array #4 (69, 70)
	- Forward Substitution Relaxation Array #5 (71, 72)
	- Forward Substitution Relaxation Array #6 (73, 74)
	- SOR Convergence Criteria Check #1 (75, 76)
	- SOR Convergence Criteria Check #2 (77, 78)
	- SOR Convergence Criteria Check #3 (79, 80)
	- SOR Convergence Criteria Check #4 (81, 82)
	- SOR Convergence Criteria Check #5 (85, 86, 87)
	- SOR Convergence Criteria Check #6 (89, 90)
	- SOR Convergence Criteria Check #7 (91, 92, 93)
	- SOR Convergence Criteria Check #8 (94, 95, 96)
	- SOR Convergence Criteria Check #9 (97, 98, 99)
	- Jacobi Iteration Matrix Illustration #1 (100, 101)
	- Jacobi Iteration Matrix Illustration #2 (105, 106)
	- Jacobi Iteration Matrix Illustration #3 (107, 108)
	- Jacobi Iteration Matrix Illustration #4 (109, 110)
	- Jacobi Iteration Matrix Illustration #5 (113, 114, 115)
	- SOR Relaxation Parameter Convergence #1 (116, 117)
	- SOR Relaxation Parameter Convergence #2 (118, 119, 120)


IdeaDRIP:

	- Tridiagonal Matrix Algorithm - Derivation (1-8)

ReleaseNotes/01_10_2024.txt

@@ -0,0 +1,68 @@
+
+Features:
+
+ - SSOR Pre-conditioning Iteration #1 (9, 10)
+ - SSOR Pre-conditioning Iteration #2 (11, 12)
+ - SSOR Pre-conditioning Iteration #3 (13, 14, 15)
+ - Symmetric Successive Over-relaxation Pre-conditioner (16)
+ - Service Env Invocation Manager Year (24)
+ - Print 1D Array Row #1 (32, 33)
+ - Print 1D Array Row #2 (34, 35)
+ - Successive Over Relaxation Iterator Setting (38, 39)
+ - Print 1D Array Row #3 (63, 64)
+ - String Util From Boolean Flag (83, 84)
+ - SOR Convergence Check Standard Instance (102, 103, 104)
+
+
+Bug Fixes/Re-organization:
+
+ - SOR Convergence Check Constructor Fix (88)
+ - SOR Convergence Jacobi Iteration Matrix (111, 112)
+
+
+Samples:
+
+ - Successive Over-relaxation Customization/Usage (17, 18)
+ - Forward Substitution Solver Annotated Shell (19, 20, 21)
+ - Forward Substitution Solver Entry Point (22, 23)
+ - SOR Forward Substitution Solver #1 (25, 26)
+ - SOR Forward Substitution Solver #2 (27, 28, 29)
+ - SOR Forward Substitution Solver #3 (30, 31)
+ - SOR Forward Substitution Solver #4 (36, 37)
+ - SOR Forward Substitution Solver #5 (40, 41, 42)
+ - SOR Forward Substitution Solver #6 (43, 44)
+ - SOR Forward Substitution Solver #7 (45, 46)
+ - SOR Forward Substitution Solver #8 (47, 48)
+ - SOR Forward Substitution Solver #9 (49, 50)
+ - SOR Forward Substitution Solver #10 (51, 52)
+ - SOR Forward Substitution Solver #11 (53, 54)
+ - SOR Forward Substitution Solver #12 (55, 56)
+ - SOR Forward Substitution Solver #13 (57, 58)
+ - SOR Forward Substitution Solver #14 (59, 60)
+ - Forward Substitution Relaxation Array #1 (61, 62)
+ - Forward Substitution Relaxation Array #2 (65, 66)
+ - Forward Substitution Relaxation Array #3 (67, 68)
+ - Forward Substitution Relaxation Array #4 (69, 70)
+ - Forward Substitution Relaxation Array #5 (71, 72)
+ - Forward Substitution Relaxation Array #6 (73, 74)
+ - SOR Convergence Criteria Check #1 (75, 76)
+ - SOR Convergence Criteria Check #2 (77, 78)
+ - SOR Convergence Criteria Check #3 (79, 80)
+ - SOR Convergence Criteria Check #4 (81, 82)
+ - SOR Convergence Criteria Check #5 (85, 86, 87)
+ - SOR Convergence Criteria Check #6 (89, 90)
+ - SOR Convergence Criteria Check #7 (91, 92, 93)
+ - SOR Convergence Criteria Check #8 (94, 95, 96)
+ - SOR Convergence Criteria Check #9 (97, 98, 99)
+ - Jacobi Iteration Matrix Illustration #1 (100, 101)
+ - Jacobi Iteration Matrix Illustration #2 (105, 106)
+ - Jacobi Iteration Matrix Illustration #3 (107, 108)
+ - Jacobi Iteration Matrix Illustration #4 (109, 110)
+ - Jacobi Iteration Matrix Illustration #5 (113, 114, 115)
+ - SOR Relaxation Parameter Convergence #1 (116, 117)
+ - SOR Relaxation Parameter Convergence #2 (118, 119, 120)
+
+
+IdeaDRIP:
+
+ - Tridiagonal Matrix Algorithm - Derivation (1-8)

src/main/java/org/drip/numerical/common/NumberUtil.java

@@ -834,6 +834,39 @@ public static final boolean Print1DArray (
  return true;
  }
 
+ /**
+ * Print the contents of the 1D array to the Specified Decimal Location as a Row
+ * 
+ * @param adblA The 1D array
+ * @param iNumDecimal Number of Decimal Places to Display
+ * @param bBailOnNaN Bail on encountering an NaN
+ * 
+ * @return Contents of the 1D array to the Specified Decimal Location as a Row
+ */
+
+ public static final String Print1DArrayRow (
+ final double[] adblA,
+ final int iNumDecimal,
+ final boolean bBailOnNaN)
+ {
+ if (null == adblA || 0 == adblA.length) return "";
+
+ int iSize = adblA.length;
+ String row = "";
+
+ for (int i = 0; i < iSize; ++i) {
+ if (!org.drip.numerical.common.NumberUtil.IsValid (adblA[i]) && bBailOnNaN) return "";
+
+ if (0 != i) {
+ row = row + " | ";
+ }
+
+ row = row + org.drip.service.common.FormatUtil.FormatDouble (adblA[i], 1, iNumDecimal, 1.);
+ }
+
+ return row;
+ }
+
  /**
  * Print the contents of the 2D array
  * 

src/main/java/org/drip/numerical/iterativesolver/SuccessiveOverRelaxation.java

@@ -153,12 +153,16 @@ public static final SuccessiveOverRelaxation Standard (
  return null;
  }
 
- private final boolean VectorsMatch (
+ protected final boolean VectorsMatch (
  final double[] array1,
  final double[] array2)
  throws Exception
  {
  for (int i = 0; i < array1.length; ++i) {
+ if (!NumberUtil.IsValid (array1[i]) || !NumberUtil.IsValid (array2[i])) {
+ throw new Exception ("SuccessiveOverRelaxation::VectorsMatch => Invalid Array Element(s)");
+ }
+
  double mid = 0.5 * (array1[i] + array2[i]);
 
  double absoluteDifference = Math.abs (array1[i] - array2[i]);
@@ -194,7 +198,7 @@ public SuccessiveOverRelaxation (
  throws Exception
  {
  if (null == (_iteratorSetting = iteratorSetting) ||
- !Matrix.IsSquare (_squareMatrix) ||
+ !Matrix.IsSquare (_squareMatrix = squareMatrix) ||
  null == (_rhsArray = rhsArray))
  {
  throw new Exception ("SuccessiveOverRelaxation Construction => Invalid Inputs");
@@ -279,17 +283,21 @@ public SuccessiveOverRelaxationIteratorSetting iteratorSetting()
 
  public double[] forwardSubstitution()
  {
+ int iteration = 0;
  double[] updatedUnknownArray = new double[_rhsArray.length];
  double[] previousUnknownArray = new double[_rhsArray.length];
 
  for (int i = 0; i < updatedUnknownArray.length; ++i) {
  updatedUnknownArray[i] = Math.random();
  }
 
+ int iterationLimit = _iteratorSetting.iterationLimit();
+
  double relaxationParameter = _iteratorSetting.relaxationParameter();
 
  try {
- while (!VectorsMatch (previousUnknownArray, updatedUnknownArray)) {
+ while (!VectorsMatch (previousUnknownArray, updatedUnknownArray) && iteration < iterationLimit)
+ {
  for (int i = 0; i < previousUnknownArray.length; ++i) {
  previousUnknownArray[i] = updatedUnknownArray[i];
  }
@@ -309,39 +317,15 @@ public double[] forwardSubstitution()
  relaxationParameter * updatedUnknownArray[i] / _squareMatrix[i][i]
  );
  }
- }
 
- return updatedUnknownArray;
+ ++iteration;
+ }
+
+ return iteration < iterationLimit ? updatedUnknownArray : null;
  } catch (Exception e) {
  e.printStackTrace();
  }
 
  return null;
  }
-
- public static final void main (
- final String[] argumentArray)
- throws Exception
- {
- double[][] squareMatrix = new double[][] {
- { 4., -1., -6., 0.},
- {-5., -4., 10., 8.},
- { 0., 9., 4., -2.},
- { 1., 0., -7., 5.},
- };
-
- double[] rhsArray = new double[] {
- 2.,
- 21.,
- -12.,
- -6.
- };
-
- NumberUtil.Print1DArray (
- "\tResult",
- SuccessiveOverRelaxation.Standard (squareMatrix, rhsArray).forwardSubstitution(),
- 4,
- false
- );
- }
 }

src/main/java/org/drip/numerical/iterativesolver/SuccessiveOverRelaxationConvergenceAnalyzer.java

@@ -128,6 +128,32 @@ public class SuccessiveOverRelaxationConvergenceAnalyzer
  private double _relaxationParameter = Double.NaN;
  private double _jacobiIterationMatrixSpectralRadius = Double.NaN;
 
+ /**
+ * Construct a Standard Instance of <i>SuccessiveOverRelaxationConvergenceAnalyzer</i>
+ * 
+ * @param squareMatrix Input Square Matrix
+ * @param jacobiIterationMatrixSpectralRadius Jacobi Iteration Matrix Spectral Radius
+ * 
+ * @return Standard Instance of <i>SuccessiveOverRelaxationConvergenceAnalyzer</i>
+ */
+
+ public static final SuccessiveOverRelaxationConvergenceAnalyzer Standard (
+ final double[][] squareMatrix,
+ final double jacobiIterationMatrixSpectralRadius)
+ {
+ try {
+ return new SuccessiveOverRelaxationConvergenceAnalyzer (
+ squareMatrix,
+ SuccessiveOverRelaxationIteratorSetting.RELAXATION_PARAMETER_DEFAULT,
+ jacobiIterationMatrixSpectralRadius
+ );
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return null;
+ }
+
  /**
  * Construct an Instance of <i>SuccessiveOverRelaxationConvergenceAnalyzer</i> from the Inputs
  * 
@@ -144,7 +170,7 @@ public SuccessiveOverRelaxationConvergenceAnalyzer (
  final double jacobiIterationMatrixSpectralRadius)
  throws Exception
  {
- if (!Matrix.IsSquare (_squareMatrix) ||
+ if (!Matrix.IsSquare (_squareMatrix = squareMatrix) ||
  !NumberUtil.IsValid (_relaxationParameter = relaxationParameter) ||
  !NumberUtil.IsValid (_jacobiIterationMatrixSpectralRadius = jacobiIterationMatrixSpectralRadius))
  {
@@ -254,11 +280,11 @@ public SuccessiveOverRelaxationConvergenceCheck check()
 
  public double optimalRelaxationParameter()
  {
- double spectralRadiusManipulator = _jacobiIterationMatrixSpectralRadius / (
+ double spectralRadiusTransformer = _jacobiIterationMatrixSpectralRadius / (
  1. + Math.sqrt (1. - _jacobiIterationMatrixSpectralRadius * _jacobiIterationMatrixSpectralRadius)
  );
 
- return 1. + spectralRadiusManipulator * spectralRadiusManipulator;
+ return 1. + spectralRadiusTransformer * spectralRadiusTransformer;
  }
 
  /**

src/main/java/org/drip/numerical/iterativesolver/SuccessiveOverRelaxationIteratorSetting.java

@@ -133,8 +133,8 @@ public class SuccessiveOverRelaxationIteratorSetting
 
  private double _absoluteTolerance = Double.NaN;
  private double _relativeTolerance = Double.NaN;
+ private int _iterationLimit = Integer.MIN_VALUE;
  private double _relaxationParameter = Double.NaN;
- private double _iterationLimit = Integer.MIN_VALUE;
  private double _absoluteLevelThreshold = Double.NaN;
 
  /**
@@ -183,6 +183,32 @@ public static final SuccessiveOverRelaxationIteratorSetting StandardGaussSeidel(
  return null;
  }
 
+ /**
+ * Construct an Instance of <i>SuccessiveOverRelaxationIteratorSetting</i> using the Relaxation Parameter
+ * 
+ * @param relaxationParameter Relaxation Parameter
+ * 
+ * @return Instance of <i>SuccessiveOverRelaxationIteratorSetting</i>
+ */
+
+ public static final SuccessiveOverRelaxationIteratorSetting StandardRelaxation (
+ final double relaxationParameter)
+ {
+ try {
+ return new SuccessiveOverRelaxationIteratorSetting (
+ ABSOLUTE_TOLERANCE_DEFAULT,
+ RELATIVE_TOLERANCE_DEFAULT,
+ ABSOLUTE_LEVEL_THRESOLD_DEFAULT,
+ relaxationParameter,
+ SOR_ITERATION_LIMIT_DEFAULT
+ );
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return null;
+ }
+
  /**
  * Construct an Instance of <i>SuccessiveOverRelaxationIteratorSetting</i> from the Inputs
  * 
@@ -267,7 +293,7 @@ public double relaxationParameter()
  * @return Iteration Limit for SOR Convergence
  */
 
- public double iterationLimit()
+ public int iterationLimit()
  {
  return _iterationLimit;
  }