} // AG public CubicSplineInterpolator(Vector <double> xarr, Vector <double> yarr, // CubicSplineBC BCType, int BCType, // double alpha = 0.0, double beta = 0.0) double alpha, double beta) : base(xarr, yarr) { // Arrays must have the same size x = xarr; y = yarr; N = xarr.Size - 1; type = BCType; a = alpha; // LHS b = beta; // RHS // Redundant internal arrays int si = x.MinIndex + 1; // !! start index // cout << "si" << si; // int t; cin >> t; double defVal = 0.0; // Calculate array of offset h = new Vector <double>(N, si, defVal); for (int j = 1; j <= N; j++) { h[j] = x[j] - x[j - 1]; } // print(h); cin >> t; // All arrays have start index 1 // Compared to the equations in the book, M(j) --> M(j+1) M = new Vector <double>(N + 1, si, defVal); // Solution A = new Vector <double>(N + 1, si, defVal); B = new Vector <double>(N + 1, si, defVal + 2.0); C = new Vector <double>(N + 1, si, defVal); r = new Vector <double>(N + 1, si, defVal); // Calculate the elements calculateVectors(); // // / print(A); print(B); print(C); int y; cin >> y; LUTridiagonalSolver mySolver = new LUTridiagonalSolver(A, B, C, r); // The matrix must be diagonally dominant; we call the // assert macro and the programs stops // assert (mySolver.diagonallyDominant() == true); C++! M = mySolver.solve(); }
public override void Ini(IEnumerable <double> xarr, IEnumerable <double> yarr) { x = new Vector <double>(xarr.ToArray(), 0); y = new Vector <double>(yarr.ToArray(), 0); N = xarr.Count() - 1; type = 1; a = 0; // LHS b = 0; // RHS // Redundant internal arrays int si = x.MinIndex + 1; // !! start index // cout << "si" << si; // int t; cin >> t; double defVal = 0.0; // Calculate array of offset h = new Vector <double>(N, si, defVal); for (int j = 1; j <= N; j++) { h[j] = x[j] - x[j - 1]; } // print(h); cin >> t; // All arrays have start index 1 // Compared to the equations in the book, M(j) --> M(j+1) M = new Vector <double>(N + 1, si, defVal); // Solution A = new Vector <double>(N + 1, si, defVal); B = new Vector <double>(N + 1, si, defVal + 2.0); C = new Vector <double>(N + 1, si, defVal); r = new Vector <double>(N + 1, si, defVal); // Calculate the elements calculateVectors(); // // / print(A); print(B); print(C); int y; cin >> y; LUTridiagonalSolver mySolver = new LUTridiagonalSolver(A, B, C, r); // The matrix must be diagonally dominant; we call the // assert macro and the programs stops // assert (mySolver.diagonallyDominant() == true); C++! M = mySolver.solve(); }
override public void calculate() { // Tells how to calculate sol. at n+1 // In general we need to solve a tridiagonal system double tmp1, tmp2; for (int i = F.MinIndex; i <= F.MaxIndex; i++) { tmp1 = (k * fitting_factor(xarr[i + 1], tnow)); tmp2 = (0.5 * k * h * (pde.convection(xarr[i + 1], tnow))); // Coefficients of the U terms A[i] = tmp1 - tmp2; B[i] = -h2 - (2.0 * tmp1) + (k * h2 * (pde.zeroterm(xarr[i + 1], tnow))); C[i] = tmp1 + tmp2; F[i] = h2 * (k * (pde.RHS(xarr[i + 1], tnow)) - vecOld[i + 1]); //?& } // Correction term for RHS F[1] -= A[1] * vecNew[vecNew.MinIndex]; F[J - 1] -= C[J - 1] * vecNew[vecNew.MaxIndex]; // Now solve the system of equations LUTridiagonalSolver mySolver = new LUTridiagonalSolver(A, B, C, F); // The matrix must be diagonally dominant; we call the // assert macro and the programs stops Vector <double> solution = mySolver.solve(); for (int ii = vecNew.MinIndex + 1; ii <= vecNew.MaxIndex - 1; ii++) { vecNew[ii] = solution[ii - 1]; } }
static void Main(string[] args) { // Jagged arrays // Lower triangular matrix int NR = 10; int NC = 10; double[][] lowerTriangular = new double[NR][]; for (int j = 0; j < NC; j++) { lowerTriangular[j] = new double[j + 1]; } // Generic arrays for starters NR = 4; NC = 4; //MatrixTwoArrayImpl<double> myMatrixStructure = new MatrixTwoArrayImpl<double>(NR, NC); UpperTriangularImpl <double> myMatrixStructure = new UpperTriangularImpl <double>(NR, NC); GenericMatrix <double, MatrixTwoArrayImpl <double> > myMatrix = new GenericMatrix <double, MatrixTwoArrayImpl <double> >(NR, NC); myMatrix.extendedPrint(); for (int i = myMatrix.MinRowIndex; i <= myMatrix.MaxRowIndex; i++) { for (int j = myMatrix.MinColumnIndex; j <= myMatrix.MaxColumnIndex; j++) { myMatrix[i, j] = -1; } } myMatrix.extendedPrint(); MatrixOneArrayImpl <double> myMatrixStructure2 = new MatrixOneArrayImpl <double>(NR, NC); GenericMatrix <double, MatrixOneArrayImpl <double> > myMatrix2 = new GenericMatrix <double, MatrixOneArrayImpl <double> >(NR, NC); myMatrix2.extendedPrint(); for (int i = myMatrix2.MinRowIndex; i <= myMatrix2.MaxRowIndex; i++) { for (int j = myMatrix2.MinColumnIndex; j <= myMatrix2.MaxColumnIndex; j++) { myMatrix2[i, j] = 2; } } myMatrix2[myMatrix2.MinRowIndex, myMatrix2.MinColumnIndex] = 99; myMatrix2[myMatrix2.MaxRowIndex, myMatrix2.MaxColumnIndex] = 98; myMatrix2.extendedPrint(); // Algebra and matrix manipulation int J = 3; Vector <double> a = new Vector <double>(J, 1, 1.0); Vector <double> b = new Vector <double>(J, 1, 2.0); Vector <double> c = new Vector <double>(J, 1, 1.0); Vector <double> r = new Vector <double>(J, 1, 0.0); // Right-hand side for (int i = r.MinIndex; i <= r.MaxIndex; i++) { r[i] = 1.0; } r[2] = -1.0; /* r[1] = 4.0; * r[2] = 10.0; * r[3] = 8.0;*/ Console.WriteLine("LU stuff"); LUTridiagonalSolver mySolver = new LUTridiagonalSolver(a, b, c, r); Vector <double> result = mySolver.solve(); Console.WriteLine("Solution"); result.extendedPrint(); // Array int startIndex = -1; Array <double> arr = new Array <double>(10, startIndex); for (int j = arr.MinIndex; j <= arr.MaxIndex; j++) { arr[j] = (double)(j); } arr[arr.MinIndex] = 99.98; // arr.extendedPrint(); // Matrix Matrix <int> mat = new Matrix <int>(4, 4, 2, 1); mat[mat.MinRowIndex, mat.MinColumnIndex] = 99; mat.initCells(3); mat[mat.MinRowIndex, mat.MinColumnIndex] = 98; mat.extendedPrint(); for (int i = mat.MinRowIndex; i <= mat.MaxRowIndex; i++) { for (int j = mat.MinColumnIndex; j <= mat.MaxColumnIndex; j++) { mat[i, j] = i * j; } } mat[mat.MinRowIndex, mat.MinColumnIndex] = 98; mat.extendedPrint(); // Vectors Vector <double> vec = new Vector <double>(10); for (int j = vec.MinIndex; j <= vec.MaxIndex; j++) { vec[j] = (double)(vec.MaxIndex - j); } vec.print(); Vector <double> vec2 = vec + vec; vec2.print(); vec2 = vec - vec; vec2.print(); vec2 = vec - 3.0; vec2.print(); vec2 = 2.0 + vec; vec2.print(); // Numeric Matrices, initial tests NumericMatrix <double> mat2 = new NumericMatrix <double>(4, 4); mat2.initCells(1.0); mat2.extendedPrint(); for (int i = mat2.MinRowIndex; i <= mat2.MaxRowIndex; i++) { for (int j = mat2.MinColumnIndex; j <= mat2.MaxColumnIndex; j++) { mat2[i, j] = i * j; } } Console.WriteLine("Matrix multiplication..."); Vector <double> vec3 = new Vector <double>(4, 1, 2.0); Vector <double> vec4 = mat2 * vec3; vec4.print(); NumericMatrix <double> mat4 = mat2 * mat2; mat4.extendedPrint(); // Numeric Matrices, testing accuracy /* int rows = 10; * int columns = 10; * int startRow = 1; * int startColumn = 1; * NumericMatrix<double> A = new NumericMatrix<double>(rows, columns, startRow, startColumn); * A[A.MinRowIndex, A.MinColumnIndex] = 1.0; A[A.MinRowIndex, A.MinColumnIndex + 1] = 2.0; * A[A.MinRowIndex + 1, A.MinColumnIndex] = 3.0; A[A.MinRowIndex + 1, A.MinColumnIndex + 1] = 4.0; * // A.extendedPrint(); * * int si = 1; // Start index * Vector<double> x = new Vector<double>(10, si); * x[si] = 1.0; * x[si + 1] = 2.0; * * Vector<double> y = A * x; * // y.extendedPrint(); * * NumericMatrix<double> B = A * A; * // B.extendedPrint(); * * B = B * B; * B = B * B; * // B.extendedPrint(); * * // Modify rows and columns of matrices * Vector<double> r1 = new Vector<double>(10, 1, 3.3); * //r1.extendedPrint(); * // A.Row(A.MinRowIndex, r1); * // A.Column(A.MaxColumnIndex, r1); * A[A.MinRowIndex, A.MinColumnIndex] = 00.0001; * A[A.MaxRowIndex, A.MaxColumnIndex] = -99.99; * A[A.MaxRowIndex, A.MinColumnIndex] = 88.88; * A.extendedPrint(); * * // Slices * Vector<double> vecSlice = A.getRow(A.MaxRowIndex); * vecSlice.extendedPrint(); * vecSlice = A.getColumn(A.MinColumnIndex); * vecSlice.extendedPrint(); * * int[, ,] tensor = new int[3, 3, 3]; * for (int i = 0; i < tensor.GetLength(0); i++) * for (int j = 0; j < tensor.GetLength(1); j++) * for (int k = 0; k < tensor.GetLength(2); k++) * tensor[i, j, k] = i * j * k; * * /* for (int i = 0; i < td.GetLength(0); i++) * for (int j = 0; j < td.GetLength(0); j++) * for (int k = 0; k < td.GetLength(0); k++) * Console.Write(td[i, j, k]); Console.Write(", ");*/ //A.Column(2, r1); // Tensors int nrows = 2; int ncols = 2; int ndepth = 10; Tensor <double> myTensor = new Tensor <double>(nrows, ncols, ndepth); // myTensor[myTensor.MinThirdIndex] = B; for (int j = myTensor.MinThirdIndex + 1; j <= myTensor.MaxThirdIndex; j++) { // myTensor[j] = A*A; } for (int j = myTensor.MinThirdIndex + 1; j <= myTensor.MaxThirdIndex; j++) { // myTensor[j].extendedPrint(); } }