|
| Newton (std::function< Vector< typename F::d_type >(Vector< typename F::d_type >)> A, Real dx, uint dimY, uint dimX, Real tol=1e-8, Real iterMax=1000) |
|
| Newton (std::function< Vector< typename F::d_type >(Vector< typename F::d_type >)> A, std::function< F(Vector< typename F::d_type >)> JacA, uint dimY, uint dimX, Real tol=1e-8, Real iterMax=50) |
|
virtual void | show_messages () |
|
virtual void | hide_messages () |
|
virtual void | apply_ (const Vector< typename F::d_type > &fncY, Vector< typename F::d_type > &fncX) |
|
virtual void | apply_ () |
|
virtual void | operator() (const Function< r_type > &fncY, Function< F > &fncX) |
|
virtual void | operator() (const Function< c_type > &fncY, Function< c_type > &fncX) |
|
virtual void | operator() (const Vector< r_type > &fncY, Vector< F > &fncX) |
|
virtual void | operator() (const Vector< c_type > &fncY, Vector< c_type > &fncX) |
|
void | operator() (const Matrix< r_type > &mX, Matrix< F > &mY) |
| Application method to real matrices. Calls function apply()
|
|
void | operator() (const Matrix< c_type > &mX, Matrix< c_type > &mY) |
| Application method to complex matrices. Calls apply_()
|
|
void | operator() () |
| Application method without second argument. Used for parallel solvers.
|
|
virtual void | operator() (const Function< r_type > &fncY, Function< F > &fncX) |
|
virtual const uint | dimX () const |
|
virtual const uint | dimY () const |
|
template<
class F>
class concepts::Newton< F >
Solves a non-linear system of the form A(X)=Y
Definition at line 35 of file newton.hh.
Application operator for complex function fncY
.
Computes fncX
= A(fncY
) where A is this operator. fncX
becomes complex.
In derived classes its enough to implement the operator() for complex Operator's. If a real counterpart is not implemented, the function fncY
is splitted into real and imaginary part and the application operator for real functions is called for each. Then the result is combined.
If in a derived class the operator() for complex Operator's is not implemented, a exception is thrown from here.
Reimplemented from concepts::Operator< F >.
Application operator for real function fncY
.
Computes fncX
= A(fncY
) where A is this operator.
fncX
becomes the type of the operator, for real data it becomes real, for complex data it becomes complex.
In derived classes its enough to implement the operator() for real Operator's. If a complex counterpart is not implemented, the function fncY
is transformed to a complex function and then the application operator for complex functions is called.
If in a derived class the operator() for real Operator's is not implemented, a exception is thrown from here.
Reimplemented in aglowav::C2W< F >, aglowav2::C2W< F >, aglowav::W2C< F >, aglowav2::W2C< F >, aglowav::C2_tl2< F >, aglowav::C2tl2< F >, aglowav::CGt2< F >, aglowav::ComposeN< F >, aglowav2::Operator00< F >, bem::D< F >, bem::D_1< F >, concepts::TrivExtendRestrict< F >, sparseqr::GivensRotations< F >, vectorial::BlockOperator< F >, concepts::TrivExtendRestrict< Real >, sparseqr::GivensRotations< Real >, concepts::AfterIteration< F >, concepts::Compose< F, H >, concepts::DDSolver< F, G >, concepts::Multiple< F >, concepts::LiCoI< F >, concepts::LiCo< F >, concepts::DenseMatrix< F >, concepts::DiagonalMatrix< F >, concepts::Permutation< F >, concepts::Matrix< F >, concepts::Matrix< F::type >, and concepts::DiagonalSolver< F >.
Application operator for complex function fncY
.
Computes fncX
= A(fncY
) where A is this operator. fncX
becomes complex.
In derived classes its enough to implement the operator() for complex Operator's. If a real counterpart is not implemented, the vector fncY
is splitted into real and imaginary part and the application operator for real vectors is called for each. Then the result is combined
If in a derived class the operator() for complex Operator's i not implemented, a exception is thrown from here.
Application operator for real vector fncY
.
Computes fncX
= A(fncY
) where A is this operator.
Type of fncX
becomes that of the operator, for real data it becomes real, for complex data it becomes complex.
In derived classes its enough to implement the operator() for real Operator's. If a complex counterpart is not implemented, the vector fncY
is transformed to a complex vector and then the application for complex vectors is called.
If in a derived class the operator() for real Operator's is not implemented, a exception is thrown from here.