private void Helper1(IElementalAccessMatrix A, IElementalAccessVector b, IElementalAccessVector x) { // Test of usual solvers and preconditoners ILinearSolver[] solver = new ILinearSolver[] { new BiCGSolver(), new BiCGstabSolver(), //new CGSolver(), new CGSSolver(), new GMRESSolver(), new QMRSolver() }; IPreconditioner[] M = new IPreconditioner[] { new IdentityPreconditioner(), //new ILUPreconditioner(new SparseRowMatrix(A.RowCount, A.ColumnCount)) }; DefaultLinearIteration iter = new DefaultLinearIteration(); iter.SetParameters(1e-10, 1e-50, 1e+5, 1000000); for (int i = 0; i < solver.Length; ++i) { for (int j = 0; j < M.Length; ++j) { Helper2(A, b, x, solver[i], M[j], iter); } } }
public PoissonBase(IMatrixAssembler assembler, IBoundaryOperable boundary, ILinearSolver solverForMassMatrix, ILinearSolver solverForStiffnessMatrix) { _assembler = assembler; _boundary = boundary; _solverM = solverForMassMatrix; _solverJ = solverForStiffnessMatrix; }
private void Helper2(IElementalAccessMatrix A, IElementalAccessVector b, IElementalAccessVector x, ILinearSolver solver, IPreconditioner M, ILinearIteration iter) { Random r = new Random(); double K = r.NextDouble(), f = r.NextDouble(), gl = r.NextDouble(), gr = r.NextDouble(); //assemble(A, b, K, f); //boundary(A, b, x, gl, gr); A.SetValue(0, 0, 1); A.SetValue(0, 1, 1); A.SetValue(0, 2, 1.3); A.SetValue(1, 0, -0.5); A.SetValue(1, 1, -0.25); A.SetValue(1, 2, -1.25); A.SetValue(2, 0, 2.5); A.SetValue(2, 1, 3.25); A.SetValue(2, 2, -1.25); b.SetValue(0, 1.25); b.SetValue(1, 3.75); b.SetValue(1, -2.35); double[] ans = solve(A, b, x, solver, M, iter); //double[] ref_Renamed = reference(b.Length - 1, K, f, gl, gr); //checkEqual(ans, ref_Renamed); Console.WriteLine("!: " + solver + " " + M + " " + iter + " " + x.GetValue(0) + " " + x.GetValue(1) + " " + x.GetValue(2)); Blas.Default.Zero(A); Blas.Default.Zero(b); Blas.Default.Zero(x); }
private double[] solve(IMatrix A, IVector b, IVector x, ILinearSolver solver, IPreconditioner M, ILinearIteration iter) { M.Setup(A); solver.Preconditioner = M; solver.Iteration = iter; return(Blas.Default.GetArrayCopy(solver.Solve(A, b, x))); }
Result <LoadIncrementalState> GetCorrection(LoadState state, LoadIncrementalState prediction, StructureInfo info) { ILinearSolver stiffnessMatrix = info.Stiffness(state.Displacement); Vector <double> dut = stiffnessMatrix.Solve(info.ReferenceLoad); Vector <double> reaction = info.Reaction(state.Displacement); Vector <double> equilibrium = info.InitialLoad + state.Lambda * info.ReferenceLoad - reaction; Vector <double> dur = stiffnessMatrix.Solve(equilibrium); Result <LoadIncrementalState> incrementalStateResult = Scheme.Correct(state, prediction, info, dut, dur); return(incrementalStateResult); }
internal LoadIncrementalState Predict(LoadState state, double initialStiffness, StructureInfo info) { Vector<double> equilibrium = info.InitialLoad + state.Lambda * info.ReferenceLoad - info.Reaction(state.Displacement); ILinearSolver mK = info.Stiffness(state.Displacement); Vector<double> Dvt = mK.Solve(info.ReferenceLoad); Vector<double> Dvr = mK.Solve(equilibrium); double bergam = GetBergamParameter(initialStiffness, Dvt, info); double DLambda = Scheme.Predict(Dvt, info.ReferenceLoad) * Math.Sign(bergam); Vector<double> Dv = DLambda * Dvt + Dvr; return new LoadIncrementalState(DLambda, Dv); }
private void Helper2(IElementalAccessMatrix A, IElementalAccessVector b, IElementalAccessVector x, ILinearSolver solver, IPreconditioner M, ILinearIteration iter) { Random r = new Random(); double K = r.NextDouble(), f = r.NextDouble(), gl = r.NextDouble(), gr = r.NextDouble(); assemble(A, b, K, f); boundary(A, b, x, gl, gr); double[] ans = solve(A, b, x, solver, M, iter); double[] ref_Renamed = reference(b.Length - 1, K, f, gl, gr); checkEqual(ans, ref_Renamed); Blas.Default.Zero(A); Blas.Default.Zero(b); Blas.Default.Zero(x); }
public IEnumerable <LoadState> Broadcast() { ILinearSolver mK0 = Info.Stiffness(State.Displacement); Vector <double> Dv0 = mK0.Solve(Info.ReferenceLoad); double k0 = Info.ReferenceLoad.DotProduct(Dv0); while (true) { LoadIncrementalState prediction = Predictor.Predict(State, k0, Info); State = State.Add(prediction); Result <LoadIncrementalState> correctionResult = Corrector.Correct(State, prediction, Info); if (correctionResult.IsSuccess) { State = State.Add(correctionResult.Value); yield return(State); } else { break; } } }
/// <summary> Constructor for AbstractMixedSolver, with CG as solver and default /// linear iteration object.</summary> public AbstractMixedSolver() { this.iter = new DefaultLinearIteration(); this.solver = new CGSolver(); blas = Blas.Default; }
/// <summary> Assigns the solver.</summary> public IterativeSolverPreconditioner(ILinearSolver preconditioner) { this.preconditioner = preconditioner; }
/// <summary> Constructor for ShiftInvertEigenvalueTransformation. The matrix Am /// must be of the same size as A, and it is overwritten. /// </summary> public ShiftInvertEigenvalueTransformation(IMatrix Am, IMatrix A) : base() { this.Am = Blas.Default.Copy(A, Am); solver_ = new GMRESSolver(); }